Base class for all Postprocessors. More...

#include <Postprocessor.h>

Inheritance diagram for Postprocessor:

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
	Postprocessor (const MooseObject *moose_object)

	Postprocessor (const Postprocessor &object, const Moose::Kokkos::FunctorCopy &key)
	Special constructor used for Kokkos functor copy during parallel dispatch.

virtual PostprocessorValue	getValue () const =0
	This will get called to actually grab the final value the postprocessor has calculated.

const PostprocessorValue &	getCurrentValue () const

const std::string &	PPName () const
	Returns the name of the Postprocessor.

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

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

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

void	buildOutputHideVariableList (std::set< std::string > variable_names)
	Builds hide lists for output objects NOT listed in the 'outputs' parameter.

const std::set< OutputName > &	getOutputs ()
	Get the list of output objects that this class is restricted.

template<>
const Moose::Functor< Real > *	defaultFunctor (const std::string &name)

template<>
const Moose::Functor< ADReal > *	defaultFunctor (const std::string &name)

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

static std::string	deduceFunctorName (const std::string &name, const InputParameters &params)
	Helper to look up a functor name through the input parameter keys.

Protected Member Functions
std::string	deduceFunctorName (const std::string &name) const
	Small helper to look up a functor name through the input parameter keys.

template<typename T >
const Moose::Functor< T > &	getFunctor (const std::string &name)
	Retrieves a functor from the subproblem.

template<typename T >
const Moose::Functor< T > &	getFunctor (const std::string &name, THREAD_ID tid)
	Retrieves a functor from the subproblem.

template<typename T >
const Moose::Functor< T > &	getFunctor (const std::string &name, SubProblem &subproblem)
	Retrieves a functor from the passed-in subproblem.

template<typename T >
const Moose::Functor< T > &	getFunctor (const std::string &name, SubProblem &subproblem, THREAD_ID tid)
	Retrieves a functor from the passed-in subproblem.

bool	isFunctor (const std::string &name) const
	Checks the subproblem for the given functor.

bool	isFunctor (const std::string &name, const SubProblem &subproblem) const
	Checks the passed-in subproblem for the given functor.

Moose::ElemArg	makeElemArg (const Elem *elem, bool correct_skewnewss=false) const
	Helper method to create an elemental argument for a functor that includes whether to perform skewness corrections.

template<typename T >
void	checkFunctorSupportsSideIntegration (const std::string &name, bool qp_integration)
	Throws error if the functor does not support the requested side integration.

template<typename T >
const Moose::Functor< T > &	getFunctorByName (const std::string &name)
	Retrieves a functor from the subproblem.

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	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
const std::string &	_pp_name
	Post-processor name.

const PostprocessorValue &	_current_value
	The current value, which is the Reporter value that changes when we execute UOs in the problem.

Private 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

Private Member Functions
const PostprocessorValue &	declareValue (const MooseObject &moose_object)
	Internal method to be used to declare the value and store it within _current_value in the constructor.

ValueType	evaluate (const ElemArg &elem, const Moose::StateArg &state) const override final
	Evaluate the functor with a given element.

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

ValueType	evaluate (const ElemQpArg &qp, const Moose::StateArg &state) const override final

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

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

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

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

GradientType	evaluateGradient (const FaceArg &face, const Moose::StateArg &state) const override final

GradientType	evaluateGradient (const ElemQpArg &qp, const Moose::StateArg &state) const override final

GradientType	evaluateGradient (const ElemSideQpArg &elem_side_qp, const Moose::StateArg &state) const override final

GradientType	evaluateGradient (const ElemPointArg &elem_point, const Moose::StateArg &state) const override final
	Evaluate the functor gradient with a given element and point.

GradientType	evaluateGradient (const NodeArg &node, const Moose::StateArg &state) const override final

DotType	evaluateDot (const ElemArg &elem, const Moose::StateArg &state) const override final
	Evaluate the functor time derivative with a given element.

DotType	evaluateDot (const FaceArg &face, const Moose::StateArg &state) const override final

DotType	evaluateDot (const ElemQpArg &qp, const Moose::StateArg &state) const override final

DotType	evaluateDot (const ElemSideQpArg &elem_side_qp, const Moose::StateArg &state) const override final

DotType	evaluateDot (const ElemPointArg &elem_point, const Moose::StateArg &state) const override final
	Evaluate the functor time derivative with a given element and point.

DotType	evaluateDot (const NodeArg &node, const Moose::StateArg &state) const override final

void	evaluateDotWarning () const
	Internal method for giving a one-time warning for calling an `evaluateDot()` method.

virtual bool	isADObject () const override
	Whether this interface is for an AD object.

template<typename T >
const Moose::Functor< T > &	getFunctorByName (const std::string &name, SubProblem &subproblem, THREAD_ID tid)
	Retrieves a functor from the passed-in subproblem.

template<typename T >
const Moose::Functor< T > *	defaultFunctor (const std::string &name)
	Helper function to parse default functor values.

template<>
const Moose::Functor< Real > *	defaultFunctor (const std::string &name)

template<>
const Moose::Functor< ADReal > *	defaultFunctor (const std::string &name)

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
const MooseObject &	_pp_moose_object
	MOOSE object.

MooseApp &	_oi_moose_app
	Reference the the MooseApp; neede for access to the OutputWarehouse.

OutputWarehouse &	_oi_output_warehouse
	Reference to the OutputWarehouse for populating the Output object hide lists.

std::set< OutputName >	_oi_outputs
	The set of Output object names listed in the 'outputs' parameter.

const InputParameters &	_fi_params
	Parameters of the object with this interface.

const std::string	_fi_name
	The name of the object that this interface belongs to.

SubProblem *const	_fi_subproblem
	Pointer to subproblem if the subproblem pointer parameter was set.

const THREAD_ID	_fi_tid
	Current threaded it.

std::vector< std::unique_ptr< Moose::Functor< Real > > >	_default_real_functors
	Storage vector for Moose::Functor<Real> default objects.

std::vector< std::unique_ptr< Moose::Functor< ADReal > > >	_default_ad_real_functors
	Storage vector for Moose::Functor<ADReal> default objects.

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

Base class for all Postprocessors.

Defines a name and sets up the virtual getValue() interface which must be overridden by derived classes.

Definition at line 23 of file Postprocessor.h.

Member Typedef Documentation

◆ DotType

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

inherited

Definition at line 150 of file MooseFunctor.h.

◆ ElemArg

using Postprocessor::ElemArg = Moose::ElemArg

private

Definition at line 89 of file Postprocessor.h.

◆ ElemPointArg

using Postprocessor::ElemPointArg = Moose::ElemPointArg

private

Definition at line 93 of file Postprocessor.h.

◆ ElemQpArg

using Postprocessor::ElemQpArg = Moose::ElemQpArg

private

Definition at line 90 of file Postprocessor.h.

◆ ElemSideQpArg

using Postprocessor::ElemSideQpArg = Moose::ElemSideQpArg

private

Definition at line 91 of file Postprocessor.h.

◆ FaceArg

using Postprocessor::FaceArg = Moose::FaceArg

private

Definition at line 92 of file Postprocessor.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 Postprocessor::NodeArg = Moose::NodeArg

private

Definition at line 94 of file Postprocessor.h.

◆ ValueType

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

inherited

Definition at line 141 of file MooseFunctor.h.

Constructor & Destructor Documentation

◆ Postprocessor() [1/2]

Postprocessor::Postprocessor ( const MooseObject * moose_object )

Definition at line 27 of file Postprocessor.C.

  : OutputInterface(moose_object->parameters()),
    NonADFunctorInterface(moose_object),
    Moose::FunctorBase<Real>(moose_object->name()),
    _pp_name(moose_object->name()),
    _current_value(declareValue(*moose_object)),
    _pp_moose_object(*moose_object)
{
}

◆ Postprocessor() [2/2]

Postprocessor::Postprocessor	(	const Postprocessor &	object,
		const Moose::Kokkos::FunctorCopy &	key
	)

Special constructor used for Kokkos functor copy during parallel dispatch.

Definition at line 38 of file Postprocessor.C.

  : OutputInterface(object, key),
    NonADFunctorInterface(object, key),
    Moose::FunctorBase<Real>(object, key),
    _pp_name(object._pp_name),
    _current_value(object._current_value),
    _pp_moose_object(object._pp_moose_object)
{
}

Member Function Documentation

◆ buildOutputHideVariableList()

void OutputInterface::buildOutputHideVariableList ( std::set< std::string > variable_names )

inherited

Builds hide lists for output objects NOT listed in the 'outputs' parameter.

Parameters

variable_names A set of variables for which the 'outputs' parameter controls

By default this is called by the constructor and passes the block name as the list of variables. This needs to be called explicitly if the build_list flag is set to False in the constructor. The latter cases is needed by the Material object to work correctly with the automatic material output capability.

Definition at line 68 of file OutputInterface.C.

{
  // Set of available names
  const std::set<OutputName> & avail = _oi_output_warehouse.getOutputNames();
 
  // Check for 'none'; hide variables on all outputs
  if (_oi_outputs.find("none") != _oi_outputs.end())
    for (const auto & name : avail)
      _oi_output_warehouse.addInterfaceHideVariables(name, variable_names);
 
  // Check for empty and 'all' in 'outputs' parameter; do not perform any variable restrictions in
  // these cases
  else if (_oi_outputs.empty() || _oi_outputs.find("all") != _oi_outputs.end())
    return;
 
  // Limit the variable output to Output objects listed
  else
  {
    // Create a list of outputs where the variable should be hidden
    std::set<OutputName> hide;
    std::set_difference(avail.begin(),
                        avail.end(),
                        _oi_outputs.begin(),
                        _oi_outputs.end(),
                        std::inserter(hide, hide.begin()));
 
    // If 'outputs' is specified add the object name to the list of items to hide
    for (const auto & name : hide)
      _oi_output_warehouse.addInterfaceHideVariables(name, variable_names);
  }
}

Referenced by ReporterTransferInterface::hideVariableHelper(), and OutputInterface::OutputInterface().

◆ 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

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

◆ checkFunctorSupportsSideIntegration()

template<typename T >

void FunctorInterface::checkFunctorSupportsSideIntegration	(	const std::string &	name,
		bool	qp_integration
	)

protectedinherited

Throws error if the functor does not support the requested side integration.

Parameters

[in]	name	Name of functor or functor parameter
[in]	qp_integration	True if performing qp integration, false if face info

Definition at line 261 of file FunctorInterface.h.

{
  const std::string functor_name = deduceFunctorName(name);
  const auto & functor = getFunctor<T>(name);
  if (qp_integration)
  {
    if (!functor.supportsElemSideQpArg())
      mooseError("Quadrature point integration was requested, but the functor '",
                 functor_name,
                 "' does not support this.");
  }
  else
  {
    if (!functor.supportsFaceArg())
      mooseError("Face info integration was requested, but the functor '",
                 functor_name,
                 "' does not support this.");
  }
}

◆ clearCacheData()

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

privateinherited

clear cache data

Definition at line 500 of file MooseFunctor.h.

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

◆ customSetup()

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

overridevirtualinherited

Implements Moose::FunctorAbstract.

Reimplemented in Function.

Definition at line 233 of file MooseFunctor.h.

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

◆ declareValue()

const PostprocessorValue & Postprocessor::declareValue ( const MooseObject & moose_object )

private

Internal method to be used to declare the value and store it within _current_value in the constructor.

Definition at line 50 of file Postprocessor.C.

{
  auto & fe_problem =
      *moose_object.parameters().getCheckedPointerParam<FEProblemBase *>("_fe_problem_base");
 
  const PostprocessorReporterName r_name(_pp_name);
 
  const bool is_thread_0 = moose_object.parameters().get<THREAD_ID>("_tid") == 0;
  mooseAssert(is_thread_0 ==
                  !fe_problem.getReporterData().hasReporterValue<PostprocessorValue>(r_name),
              "Postprocessor Reporter threaded value declaration mismatch");
 
  // Declare the Reporter value on thread 0 only; this lets us add error checking to
  // make sure that it really is added only once
  if (is_thread_0)
    fe_problem.getReporterData(ReporterData::WriteKey())
        .declareReporterValue<PostprocessorValue, ReporterGeneralContext<PostprocessorValue>>(
            r_name, REPORTER_MODE_UNSET, moose_object);
 
  // At this point, thread 0 should have declared the value and getting it should be valid
  return fe_problem.getReporterData().getReporterValue<PostprocessorValue>(r_name);
}

◆ deduceFunctorName() [1/2]

std::string FunctorInterface::deduceFunctorName ( const std::string & name ) const

protectedinherited

Small helper to look up a functor name through the input parameter keys.

Definition at line 71 of file FunctorInterface.C.

{
  return deduceFunctorName(name, _fi_params);
}

◆ deduceFunctorName() [2/2]

std::string FunctorInterface::deduceFunctorName	(	const std::string &	name,
		const InputParameters &	params
	)

staticinherited

Helper to look up a functor name through the input parameter keys.

Parameters

name	The input parameter name that we are trying to deduce the functor name for
params	The input parameters object that we will be checking for parameters named `name`

Returns: The functor name

Definition at line 39 of file FunctorInterface.C.

{
  if (params.isParamValid(name))
  {
    if (params.have_parameter<MooseFunctorName>(name))
      return params.get<MooseFunctorName>(name);
    // variables, functor material properties, functions, and post-processors are also functors
    else if (params.have_parameter<MaterialPropertyName>(name))
      return params.get<MaterialPropertyName>(name);
    else if (params.have_parameter<VariableName>(name))
      return params.get<VariableName>(name);
    else if (params.have_parameter<std::vector<VariableName>>(name))
    {
      const auto & var_names = params.get<std::vector<VariableName>>(name);
      if (var_names.size() != 1)
        mooseError("We only support a single variable name for retrieving a functor");
      return var_names[0];
    }
    else if (params.have_parameter<NonlinearVariableName>(name))
      return params.get<NonlinearVariableName>(name);
    else if (params.have_parameter<FunctionName>(name))
      return params.get<FunctionName>(name);
    else if (params.have_parameter<PostprocessorName>(name))
      return params.get<PostprocessorName>(name);
    else
      mooseError("Invalid parameter type for retrieving a functor");
  }
  else
    return name;
}

Referenced by FunctorInterface::checkFunctorSupportsSideIntegration(), FunctorInterface::deduceFunctorName(), FunctorInterface::getFunctor(), and FunctorInterface::isFunctor().

◆ defaultFunctor() [1/5]

template<typename T >

const Moose::Functor< T > * FunctorInterface::defaultFunctor ( const std::string & name )

privateinherited

Helper function to parse default functor values.

This is implemented as a specialization for supported types and returns NULL in all other cases.

Definition at line 254 of file FunctorInterface.h.

{
  return nullptr;
}

◆ defaultFunctor() [2/5]

template<>

const Moose::Functor< Real > * FunctorInterface::defaultFunctor ( const std::string & name )

privateinherited

◆ defaultFunctor() [3/5]

template<>

const Moose::Functor< ADReal > * FunctorInterface::defaultFunctor ( const std::string & name )

privateinherited

◆ defaultFunctor() [4/5]

template<>

const Moose::Functor< Real > * FunctorInterface::defaultFunctor ( const std::string & name )

inherited

Definition at line 78 of file FunctorInterface.C.

{
  std::istringstream ss(name);
  Real real_value;
 
  // check if the string parsed cleanly into a Real number
  if (ss >> real_value && ss.eof())
  {
    _default_real_functors.emplace_back(std::make_unique<Moose::Functor<Real>>(
        std::make_unique<Moose::ConstantFunctor<Real>>(real_value)));
    auto & default_property = _default_real_functors.back();
    return default_property.get();
  }
 
  return nullptr;
}

◆ defaultFunctor() [5/5]

template<>

const Moose::Functor< ADReal > * FunctorInterface::defaultFunctor ( const std::string & name )

inherited

Definition at line 97 of file FunctorInterface.C.

{
  std::istringstream ss(name);
  Real real_value;
 
  // check if the string parsed cleanly into a Real number
  if (ss >> real_value && ss.eof())
  {
    _default_ad_real_functors.emplace_back(std::make_unique<Moose::Functor<ADReal>>(
        std::make_unique<Moose::ConstantFunctor<ADReal>>(real_value)));
    auto & default_property = _default_ad_real_functors.back();
    return default_property.get();
  }
 
  return nullptr;
}

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

{
  return evaluateDot(elem, state);
}

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

{
  return evaluateDot(elem_point, state);
}

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

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

{
  return evaluateDot(elem_side_qp, state);
}

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

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

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

{
  return evaluateDot(node, state);
}

◆ evaluate() [1/6]

Postprocessor::ValueType Postprocessor::evaluate	(	const ElemArg &	elem,
		const Moose::StateArg &	state
	)		const

finaloverrideprivatevirtual

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 74 of file Postprocessor.C.

{
  return getCurrentValue();
}

◆ evaluate() [2/6]

Postprocessor::ValueType Postprocessor::evaluate	(	const ElemPointArg &	elem_point,
		const Moose::StateArg &	state
	)		const

finaloverrideprivatevirtual

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 99 of file Postprocessor.C.

{
  return getCurrentValue();
}

◆ evaluate() [3/6]

Postprocessor::ValueType Postprocessor::evaluate	(	const ElemQpArg &	qp,
		const Moose::StateArg &	state
	)		const

finaloverrideprivatevirtual

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 86 of file Postprocessor.C.

{
  return getCurrentValue();
}

◆ evaluate() [4/6]

Postprocessor::ValueType Postprocessor::evaluate	(	const ElemSideQpArg &	side_qp,
		const Moose::StateArg &	state
	)		const

finaloverrideprivatevirtual

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 92 of file Postprocessor.C.

{
  return getCurrentValue();
}

◆ evaluate() [5/6]

Postprocessor::ValueType Postprocessor::evaluate	(	const FaceArg &	face,
		const Moose::StateArg &	state
	)		const

finaloverrideprivatevirtual

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 80 of file Postprocessor.C.

{
  return getCurrentValue();
}

◆ evaluate() [6/6]

Postprocessor::ValueType Postprocessor::evaluate	(	const NodeArg &	node,
		const Moose::StateArg &	state
	)		const

finaloverrideprivatevirtual

Implements Moose::FunctorBase< Real >.

Definition at line 106 of file Postprocessor.C.

{
  return getCurrentValue();
}

◆ evaluateDot() [1/6]

Postprocessor::DotType Postprocessor::evaluateDot	(	const ElemArg &	,
		const Moose::StateArg &
	)		const

finaloverrideprivatevirtual

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

Definition at line 153 of file Postprocessor.C.

{
  evaluateDotWarning();
  return 0;
}

◆ evaluateDot() [2/6]

Postprocessor::DotType Postprocessor::evaluateDot	(	const ElemPointArg &	,
		const Moose::StateArg &
	)		const

finaloverrideprivatevirtual

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

Reimplemented from Moose::FunctorBase< Real >.

Definition at line 182 of file Postprocessor.C.

{
  evaluateDotWarning();
  return 0;
}

◆ evaluateDot() [3/6]

Postprocessor::DotType Postprocessor::evaluateDot	(	const ElemQpArg &	,
		const Moose::StateArg &
	)		const

finaloverrideprivatevirtual

Parameters

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

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

Reimplemented from Moose::FunctorBase< Real >.

Definition at line 167 of file Postprocessor.C.

{
  evaluateDotWarning();
  return 0;
}

◆ evaluateDot() [4/6]

Postprocessor::DotType Postprocessor::evaluateDot	(	const ElemSideQpArg &	,
		const Moose::StateArg &
	)		const

finaloverrideprivatevirtual

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

Definition at line 174 of file Postprocessor.C.

{
  evaluateDotWarning();
  return 0;
}

◆ evaluateDot() [5/6]

Postprocessor::DotType Postprocessor::evaluateDot	(	const FaceArg &	,
		const Moose::StateArg &
	)		const

finaloverrideprivatevirtual

Parameters

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

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

Reimplemented from Moose::FunctorBase< Real >.

Definition at line 160 of file Postprocessor.C.

{
  evaluateDotWarning();
  return 0;
}

◆ evaluateDot() [6/6]

Postprocessor::DotType Postprocessor::evaluateDot	(	const NodeArg &	node,
		const Moose::StateArg &	state
	)		const

finaloverrideprivatevirtual

Reimplemented from Moose::FunctorBase< Real >.

Definition at line 190 of file Postprocessor.C.

{
  evaluateDotWarning();
  return 0;
}

◆ evaluateDotWarning()

void Postprocessor::evaluateDotWarning ( ) const

private

Internal method for giving a one-time warning for calling an evaluateDot() method.

Definition at line 197 of file Postprocessor.C.

{
  mooseDoOnce(_pp_moose_object.mooseWarning(
      "The time derivative functor operator was called on this post-processor.\n\nA zero value "
      "will always be returned, even if the post-processor value changes with time."));
}

Referenced by evaluateDot(), evaluateDot(), evaluateDot(), evaluateDot(), evaluateDot(), and evaluateDot().

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

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

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

  {
    mooseError("Element-point 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

Definition at line 465 of file MooseFunctor.h.

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

◆ evaluateGradDot() [4/6]

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

inlineprotectedvirtualinherited

Parameters

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

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

Definition at line 476 of file MooseFunctor.h.

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

◆ evaluateGradDot() [5/6]

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

inlineprotectedvirtualinherited

Parameters

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

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

Definition at line 455 of file MooseFunctor.h.

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

◆ evaluateGradDot() [6/6]

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

inlineprotectedvirtualinherited

Definition at line 490 of file MooseFunctor.h.

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

◆ evaluateGradient() [1/6]

Postprocessor::GradientType Postprocessor::evaluateGradient	(	const ElemArg &	,
		const Moose::StateArg &
	)		const

finaloverrideprivatevirtual

Evaluate the functor gradient with a given element.

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

Reimplemented from Moose::FunctorBase< Real >.

Definition at line 112 of file Postprocessor.C.

{
  return 0;
}

◆ evaluateGradient() [2/6]

Postprocessor::GradientType Postprocessor::evaluateGradient	(	const ElemPointArg &	,
		const Moose::StateArg &
	)		const

finaloverrideprivatevirtual

Evaluate the functor gradient with a given element and point.

Reimplemented from Moose::FunctorBase< Real >.

Definition at line 139 of file Postprocessor.C.

{
  return 0;
}

◆ evaluateGradient() [3/6]

Postprocessor::GradientType Postprocessor::evaluateGradient	(	const ElemQpArg &	,
		const Moose::StateArg &
	)		const

finaloverrideprivatevirtual

Parameters

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

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

Reimplemented from Moose::FunctorBase< Real >.

Definition at line 125 of file Postprocessor.C.

{
  return 0;
}

◆ evaluateGradient() [4/6]

Postprocessor::GradientType Postprocessor::evaluateGradient	(	const ElemSideQpArg &	,
		const Moose::StateArg &
	)		const

finaloverrideprivatevirtual

Parameters

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

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

Reimplemented from Moose::FunctorBase< Real >.

Definition at line 132 of file Postprocessor.C.

{
  return 0;
}

◆ evaluateGradient() [5/6]

Postprocessor::GradientType Postprocessor::evaluateGradient	(	const FaceArg &	,
		const Moose::StateArg &
	)		const

finaloverrideprivatevirtual

Parameters

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

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

Reimplemented from Moose::FunctorBase< Real >.

Definition at line 119 of file Postprocessor.C.

{
  return 0;
}

◆ evaluateGradient() [6/6]

Postprocessor::GradientType Postprocessor::evaluateGradient	(	const NodeArg &	node,
		const Moose::StateArg &	state
	)		const

finaloverrideprivatevirtual

Reimplemented from Moose::FunctorBase< Real >.

Definition at line 146 of file Postprocessor.C.

{
  return 0;
}

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

{
  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);
}

◆ getCurrentValue()

const PostprocessorValue & Postprocessor::getCurrentValue ( ) const

inline

Returns: The "current" value of this Postprocessor.

Your sanity would tell you... why not just call getValue()? Well - the intention of getValue() is to be called by the problem when the UserObjects are executed, and not by other things. This enables the control of when this Postprocessor is updated, which could be very important. If the implementation of getValue() is such that it actually computes a new value (instead of one that is called in finalize()), you could potentially call getValue() and not get the value as it was at the last time this PP was executed.

What this does instead is gives you the value that was last set as this PP was executed by the problem. That is, the value that every object that uses the PostprocessorInterface will get you.

Definition at line 63 of file Postprocessor.h.

63{ return _current_value; }

Referenced by evaluate(), evaluate(), evaluate(), evaluate(), evaluate(), and evaluate().

◆ getFunctor() [1/4]

template<typename T >

const Moose::Functor< T > & FunctorInterface::getFunctor ( const std::string & name )

protectedinherited

Retrieves a functor from the subproblem.

This method also leverages the ability to create default functors if the user passed an integer or real in the input file

Parameters

name	The name of the functor to retrieve. This should match the functor parameter name, \emph not the actual name of the functor created in the input file

Returns: The functor

Definition at line 217 of file FunctorInterface.h.

{
  mooseAssert(_fi_subproblem, "This must be non-null");
  return getFunctor<T>(name, *_fi_subproblem, _fi_tid);
}

Referenced by GenericFunctorGradientMaterialTempl< is_ad >::GenericFunctorGradientMaterialTempl(), GenericFunctorMaterialTempl< is_ad >::GenericFunctorMaterialTempl(), GenericVectorFunctorMaterialTempl< is_ad >::GenericVectorFunctorMaterialTempl(), MaterialFunctorConverterTempl< T >::MaterialFunctorConverterTempl(), and ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl().

◆ getFunctor() [2/4]

template<typename T >

const Moose::Functor< T > & FunctorInterface::getFunctor	(	const std::string &	name,
		SubProblem &	subproblem
	)

protectedinherited

Retrieves a functor from the passed-in subproblem.

This method also leverages the ability to create default functors if the user passed an integer or real in the input file

Parameters

name	The name of the functor to retrieve. This should match the functor parameter name, \emph not the actual name of the functor created in the input file
subproblem	The subproblem to query for the functor

Returns: The functor

Definition at line 202 of file FunctorInterface.h.

{
  return getFunctor<T>(name, subproblem, _fi_tid);
}

◆ getFunctor() [3/4]

template<typename T >

const Moose::Functor< T > & FunctorInterface::getFunctor	(	const std::string &	name,
		SubProblem &	subproblem,
		THREAD_ID	tid
	)

protectedinherited

Retrieves a functor from the passed-in subproblem.

This method also leverages the ability to create default functors if the user passed an integer or real in the input file

Parameters

name	The name of the functor to retrieve. This should match the functor parameter name, \emph not the actual name of the functor created in the input file
subproblem	The subproblem to query for the functor
tid	The thread ID used to retrieve the functor from the `subproblem`

Returns: The functor

Definition at line 193 of file FunctorInterface.h.

{
  // Check if the supplied parameter is a valid input parameter key
  std::string functor_name = deduceFunctorName(name);
  return getFunctorByName<T>(functor_name, subproblem, tid);
}

◆ getFunctor() [4/4]

template<typename T >

const Moose::Functor< T > & FunctorInterface::getFunctor	(	const std::string &	name,
		THREAD_ID	tid
	)

protectedinherited

Retrieves a functor from the subproblem.

This method also leverages the ability to create default functors if the user passed an integer or real in the input file

Parameters

name	The name of the functor to retrieve. This should match the functor parameter name, \emph not the actual name of the functor created in the input file
tid	The thread ID used to retrieve the functor from this interface's subproblem

Returns: The functor

Definition at line 209 of file FunctorInterface.h.

{
  mooseAssert(_fi_subproblem, "This must be non-null");
  return getFunctor<T>(name, *_fi_subproblem, tid);
}

◆ getFunctorByName() [1/2]

template<typename T >

const Moose::Functor< T > & FunctorInterface::getFunctorByName ( const std::string & name )

protectedinherited

Retrieves a functor from the subproblem.

This method also leverages the ability to create default functors if the user passed an integer or real in the input file

Parameters

name	The name of the functor to retrieve. This should match the actual name of the functor created in the input file

Returns: The functor

Definition at line 225 of file FunctorInterface.h.

{
  mooseAssert(_fi_subproblem, "This must be non-null");
  return getFunctorByName<T>(name, *_fi_subproblem, _fi_tid);
}

◆ getFunctorByName() [2/2]

template<typename T >

const Moose::Functor< T > & FunctorInterface::getFunctorByName	(	const std::string &	name,
		SubProblem &	subproblem,
		THREAD_ID	tid
	)

privateinherited

Retrieves a functor from the passed-in subproblem.

This method also leverages the ability to create default functors if the user passed an integer or real in the input file

Parameters

name	The actual name of the functor to retrieve instead of the parameter name
subproblem	The subproblem to query for the functor
tid	The thread ID used to retrieve the functor from the `subproblem`

Returns: The functor

Definition at line 233 of file FunctorInterface.h.

{
  // Check if it's just a constant
  const auto * const default_functor = defaultFunctor<T>(name);
  if (default_functor)
    return *default_functor;
 
  return subproblem.getFunctor<T>(name, tid, _fi_name, isADObject());
}

◆ getOutputs()

const std::set< OutputName > & OutputInterface::getOutputs ( )

inherited

Get the list of output objects that this class is restricted.

Returns: A set of OutputNames

Definition at line 101 of file OutputInterface.C.

{
  return _oi_outputs;
}

◆ getValue()

virtual PostprocessorValue Postprocessor::getValue ( ) const

pure virtual

This will get called to actually grab the final value the postprocessor has calculated.

Note that this should only be called by internal methods, namely the problem that actually sets the value globally for other things to use. If you want the value outside of one of these external methods, you should use getCurrentValue().

Implemented in KokkosExtremeValueBase< KokkosElementVariablePostprocessor >, KokkosExtremeValueBase< KokkosNodalVariablePostprocessor >, KokkosExtremeValueBase< KokkosSideVariablePostprocessor >, KokkosNodalL2Norm, KokkosNodalMaxValueId, KokkosNodalSum, KokkosSumPostprocessor, LibtorchControlValuePostprocessor, AverageElementSize, AverageNodalVariableValue, AverageVariableChange, ChainControlDataPostprocessor, ChangeOverFixedPointPostprocessor, ChangeOverTimePostprocessor, ConstantPostprocessor, CumulativeValuePostprocessor, DifferencePostprocessor, DiscreteVariableResidualNorm, ElementalVariableValue, ElementArrayL2Norm, ElementAverageFunctorPostprocessor, ElementAverageMaterialPropertyTempl< is_ad >, ElementAverageValue, ElementExtremeMaterialPropertyTempl< is_ad >, ElementH1SemiError, ElementIntegralPostprocessor, ElementL2Difference, ElementL2Error, ElementL2FunctorErrorTempl< is_ad >, ElementL2Norm, ElementMaxLevelPostProcessor, ElementSidesL2Norm, ElementVectorL2Error, ElementW1pError, EmptyPostprocessor, ExtremeValueBase< ElementPostprocessor >, ExtremeValueBase< ElementVariablePostprocessor >, ExtremeValueBase< NodalVariablePostprocessor >, ExtremeValueBase< SideVariablePostprocessor >, FindValueOnLine, FunctionElementAverage, FunctionSideAverage, FunctionValuePostprocessor, GreaterThanLessThanPostprocessor, InterfaceAverageVariableValuePostprocessor, InterfaceDiffusiveFluxAverageTempl< is_ad >, InterfaceIntegralPostprocessor, InternalSideIntegralPostprocessor, LinearCombinationPostprocessor, MatrixSymmetryCheck, MemoryUsage, NearestNodeNumber, NodalL2Error, NodalL2Norm, NodalMaxValue, NodalMaxValueId, NodalSum, NodalVariableValue, NumDOFs, NumElements, NumFailedTimeSteps, NumFixedPointIterations, NumLinearIterations, NumMeshDivisions, NumNodes, NumNonlinearIterations, NumPositions, NumRelationshipManagers, NumResidualEvaluations, NumTimeSteps, NumVars, PercentChangePostprocessor, PerfGraphData, PointValue, PostprocessorComparison, PseudoTimestep, Receiver, RelativeDifferencePostprocessor, RelativeSolutionDifferenceNorm, Residual, ScalarL2Error, ScalarVariable, ScalePostprocessor, SideAverageFunctorPostprocessor, SideAverageMaterialPropertyTempl< is_ad >, SideAverageValue, SideDiffusiveFluxAverageTempl< is_ad >, SideIntegralPostprocessor, SumPostprocessor, TagVectorSum, TimeExtremeValue, TimeIntegratedPostprocessor, TimePostprocessor, TimestepSize, VariableResidual, VectorPostprocessorComparison, VectorPostprocessorComponent, VectorPostprocessorReductionValue, MFEMComplexVectorPeriodAveragedPostprocessor, MFEML2Error, MFEMVectorBoundaryFluxIntegralPostprocessor, MFEMVectorFEInnerProductIntegralPostprocessor, MFEMVectorL2Error, ParsedPostprocessor, NumMeshDivisions, PseudoTimestep, and TagVectorSum.

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

{
  return evaluateGradDot(elem, state);
}

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

{
  return evaluateGradDot(elem_point, state);
}

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

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

{
  return evaluateGradDot(elem_side_qp, state);
}

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

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

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

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

{
  return evaluateGradient(elem, state);
}

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

{
  return evaluateGradient(elem_point, state);
}

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

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

{
  return evaluateGradient(elem_side_qp, state);
}

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

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

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

{
  return evaluateGradient(node, state);
}

◆ hasBlocks()

virtual bool Postprocessor::hasBlocks ( SubdomainID ) const

inlineoverridevirtual

Returns whether the functor is defined on this block.

Reimplemented from Moose::FunctorBase< Real >.

Definition at line 70 of file Postprocessor.h.

70{ return true; }

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

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

◆ isADObject()

virtual bool NonADFunctorInterface::isADObject ( ) const

inlineoverrideprivatevirtualinherited

Whether this interface is for an AD object.

Implements FunctorInterface.

Definition at line 35 of file NonADFunctorInterface.h.

35{ return false; }

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

  {
    mooseError("not implemented");
  }

◆ isFunctor() [1/2]

bool FunctorInterface::isFunctor ( const std::string & name ) const

protectedinherited

Checks the subproblem for the given functor.

This will not query default functors potentially stored in this object, e.g. this method will return false if the user passed an int or real to the functor param in the input file

Parameters

name	The name of the functor to check. This should match the functor parameter name, \emph not the actual name of the functor created in the input file

Returns: Whether the subproblem has the specified functor

Definition at line 124 of file FunctorInterface.C.

{
  mooseAssert(_fi_subproblem, "This must be non-null");
  return isFunctor(name, *_fi_subproblem);
}

Referenced by FunctorInterface::isFunctor().

◆ isFunctor() [2/2]

bool FunctorInterface::isFunctor	(	const std::string &	name,
		const SubProblem &	subproblem
	)		const

protectedinherited

Checks the passed-in subproblem for the given functor.

This will not query default functors potentially stored in this object, e.g. this method will return false if the user passed an int or real to the functor param in the input file

Parameters

name	The name of the functor to check. This should match the functor parameter name, \emph not the actual name of the functor created in the input file
subproblem	The subproblem to query for the functor

Returns: Whether the subproblem has the specified functor

Definition at line 115 of file FunctorInterface.C.

{
  // Check if the supplied parameter is a valid input parameter key
  std::string functor_name = deduceFunctorName(name);
 
  return subproblem.hasFunctor(functor_name, _fi_tid);
}

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

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

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

◆ makeElemArg()

Moose::ElemArg FunctorInterface::makeElemArg	(	const Elem *	elem,
		bool	correct_skewnewss = `false`
	)		const

protectedinherited

Helper method to create an elemental argument for a functor that includes whether to perform skewness corrections.

Definition at line 131 of file FunctorInterface.C.

{
  return {elem, correct_skewness};
}

Referenced by LinearFVAdvectionDiffusionFunctorDirichletBC::computeBoundaryNormalGradient(), LinearFVReaction::computeMatrixContribution(), LinearFVTimeDerivative::computeMatrixContribution(), FVCoupledForce::computeQpResidual(), FVFunctorTimeKernel::computeQpResidual(), FVMassMatrix::computeQpResidual(), FVBoundedValueConstraint::computeQpResidual(), FVIntegralValueConstraint::computeQpResidual(), FVPointValueConstraint::computeQpResidual(), LinearFVSource::computeRightHandSideContribution(), FunctorAux::computeValue(), FunctorCoordinatesFunctionAux::computeValue(), SecondTimeDerivativeAux::computeValue(), TimeDerivativeAux::computeValue(), LinearFVAnisotropicDiffusion::faceDiffusionTensor(), FunctorTimes::initialize(), and LinearFVTimeDerivative::setCurrentElemInfo().

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

{
  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 ElemPointArg &	elem_point,
		const StateArg &	state
	)		const

inherited

Definition at line 187 of file MooseFunctor.h.

{
  return evaluate(elem_point, state);
}

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

{
  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 186 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 FaceArg &	face,
		const StateArg &	state
	)		const

inherited

Definition at line 184 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()() [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.

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

◆ PPName()

const std::string & Postprocessor::PPName ( ) const

inline

Returns the name of the Postprocessor.

Definition at line 68 of file Postprocessor.h.

68{ return _pp_name; }

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

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

◆ queryQpCache()

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.

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

◆ residualSetup()

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

overridevirtualinherited

Implements Moose::FunctorAbstract.

Reimplemented in Function.

Definition at line 230 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 238 of file MooseFunctor.h.

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

◆ supportsElemSideQpArg()

bool Postprocessor::supportsElemSideQpArg ( ) const

inlinefinaloverridevirtual

Whether this functor supports evaluation with ElemSideQpArg.

Implements Moose::FunctorBase< Real >.

Definition at line 73 of file Postprocessor.h.

73{ return true; }

◆ supportsFaceArg()

bool Postprocessor::supportsFaceArg ( ) const

inlinefinaloverridevirtual

Whether this functor supports evaluation with FaceArg.

Implements Moose::FunctorBase< Real >.

Definition at line 72 of file Postprocessor.h.

72{ return true; }

◆ timestepSetup()

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

overridevirtualinherited

Implements Moose::FunctorAbstract.

Reimplemented in Function, MemoryUsage, and NumNonlinearIterations.

Definition at line 232 of file MooseFunctor.h.

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

◆ validParams()

InputParameters Postprocessor::validParams ( )

static

Definition at line 17 of file Postprocessor.C.

{
  InputParameters params = OutputInterface::validParams();
  params += NonADFunctorInterface::validParams();
 
  params.addParamNamesToGroup("outputs", "Advanced");
  params.registerBase("Postprocessor");
  return params;
}

Referenced by MFEMPostprocessor::validParams(), ElementPostprocessor::validParams(), GeneralPostprocessor::validParams(), InterfacePostprocessor::validParams(), InternalSidePostprocessor::validParams(), NodalPostprocessor::validParams(), and SidePostprocessor::validParams().

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.

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

◆ _current_value

const PostprocessorValue& Postprocessor::_current_value

protected

The current value, which is the Reporter value that changes when we execute UOs in the problem.

Definition at line 80 of file Postprocessor.h.

Referenced by getCurrentValue().

◆ _default_ad_real_functors

std::vector<std::unique_ptr<Moose::Functor<ADReal> > > FunctorInterface::_default_ad_real_functors

privateinherited

Storage vector for Moose::Functor<ADReal> default objects.

Definition at line 188 of file FunctorInterface.h.

Referenced by FunctorInterface::defaultFunctor().

◆ _default_real_functors

std::vector<std::unique_ptr<Moose::Functor<Real> > > FunctorInterface::_default_real_functors

privateinherited

Storage vector for Moose::Functor<Real> default objects.

Definition at line 185 of file FunctorInterface.h.

Referenced by FunctorInterface::defaultFunctor().

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

◆ _fi_name

const std::string FunctorInterface::_fi_name

privateinherited

The name of the object that this interface belongs to.

Definition at line 176 of file FunctorInterface.h.

Referenced by FunctorInterface::getFunctorByName().

◆ _fi_params

const InputParameters& FunctorInterface::_fi_params

privateinherited

Parameters of the object with this interface.

Definition at line 173 of file FunctorInterface.h.

Referenced by FunctorInterface::deduceFunctorName().

◆ _fi_subproblem

SubProblem* const FunctorInterface::_fi_subproblem

privateinherited

Pointer to subproblem if the subproblem pointer parameter was set.

Definition at line 179 of file FunctorInterface.h.

Referenced by FunctorInterface::getFunctor(), FunctorInterface::getFunctor(), FunctorInterface::getFunctorByName(), and FunctorInterface::isFunctor().

◆ _fi_tid

const THREAD_ID FunctorInterface::_fi_tid

privateinherited

Current threaded it.

Definition at line 182 of file FunctorInterface.h.

Referenced by FunctorInterface::getFunctor(), FunctorInterface::getFunctor(), FunctorInterface::getFunctorByName(), and FunctorInterface::isFunctor().

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

◆ _oi_moose_app

MooseApp& OutputInterface::_oi_moose_app

privateinherited

Reference the the MooseApp; neede for access to the OutputWarehouse.

Definition at line 72 of file OutputInterface.h.

◆ _oi_output_warehouse

OutputWarehouse& OutputInterface::_oi_output_warehouse

privateinherited

Reference to the OutputWarehouse for populating the Output object hide lists.

Definition at line 75 of file OutputInterface.h.

Referenced by OutputInterface::buildOutputHideVariableList().

◆ _oi_outputs

std::set<OutputName> OutputInterface::_oi_outputs

privateinherited

The set of Output object names listed in the 'outputs' parameter.

Definition at line 78 of file OutputInterface.h.

Referenced by OutputInterface::buildOutputHideVariableList(), and OutputInterface::getOutputs().

◆ _pp_moose_object

const MooseObject& Postprocessor::_pp_moose_object

private

MOOSE object.

Definition at line 133 of file Postprocessor.h.

Referenced by evaluateDotWarning().

◆ _pp_name

const std::string& Postprocessor::_pp_name

protected

Post-processor name.

Definition at line 77 of file Postprocessor.h.

Referenced by declareValue(), and PPName().

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

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

include/postprocessors/Postprocessor.h
src/postprocessors/Postprocessor.C

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ DotType

◆ ElemArg

◆ ElemPointArg

◆ ElemQpArg

◆ ElemSideQpArg

◆ FaceArg

◆ FunctorType

◆ GradientType

◆ NodeArg

◆ ValueType

Constructor & Destructor Documentation

◆ Postprocessor() [1/2]

◆ Postprocessor() [2/2]

Member Function Documentation

◆ buildOutputHideVariableList()

◆ checkFace()

◆ checkFunctorSupportsSideIntegration()

◆ clearCacheData()

◆ customSetup()

◆ declareValue()

◆ deduceFunctorName() [1/2]

◆ deduceFunctorName() [2/2]

◆ defaultFunctor() [1/5]

◆ defaultFunctor() [2/5]

◆ defaultFunctor() [3/5]

◆ defaultFunctor() [4/5]

◆ defaultFunctor() [5/5]

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

◆ evaluateDotWarning()

◆ evaluateGradDot() [1/6]

◆ evaluateGradDot() [2/6]

◆ evaluateGradDot() [3/6]

◆ evaluateGradDot() [4/6]

◆ evaluateGradDot() [5/6]

◆ evaluateGradDot() [6/6]

◆ evaluateGradient() [1/6]

◆ evaluateGradient() [2/6]

◆ evaluateGradient() [3/6]

◆ evaluateGradient() [4/6]

◆ evaluateGradient() [5/6]

◆ evaluateGradient() [6/6]

◆ functorName()

◆ genericEvaluate()

◆ getCurrentValue()

◆ getFunctor() [1/4]

◆ getFunctor() [2/4]

◆ getFunctor() [3/4]

◆ getFunctor() [4/4]

◆ getFunctorByName() [1/2]

◆ getFunctorByName() [2/2]

◆ getOutputs()

◆ getValue()

◆ gradDot() [1/6]