PostprocessorInterface Class Reference

Interface class for classes which interact with Postprocessors. More...

#include <PostprocessorInterface.h>

Inheritance diagram for PostprocessorInterface:

Public Member Functions
	PostprocessorInterface (const MooseObject *moose_object)
	PostprocessorInterface (const FEProblemBase *problem)
	PostprocessorInterface (const PostprocessorInterface &object, const Moose::Kokkos::FunctorCopy &key)
	Special constructor used for Kokkos functor copy during parallel dispatch.
bool	isDefaultPostprocessorValue (const std::string &param_name, const unsigned int index=0) const
	Determine whether or not the Postprocessor is a default value.
bool	hasPostprocessor (const std::string &param_name, const unsigned int index=0) const
	Determine if the Postprocessor data exists.
bool	hasPostprocessorByName (const PostprocessorName &name) const
	Determine if the Postprocessor data exists.
std::size_t	coupledPostprocessors (const std::string &param_name) const
	Returns number of Postprocessors coupled under parameter name.
const PostprocessorName &	getPostprocessorName (const std::string &param_name, const unsigned int index=0) const
	Get the name of a postprocessor.
const PostprocessorValue &	getPostprocessorValue (const std::string &param_name, const unsigned int index=0) const
	doco-normal-methods-begin Retrieve the value of a Postprocessor or one of it's old or older values
const PostprocessorValue &	getPostprocessorValueOld (const std::string &param_name, const unsigned int index=0) const
const PostprocessorValue &	getPostprocessorValueOlder (const std::string &param_name, const unsigned int index=0) const
virtual const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name) const
	Retrieve the value of the Postprocessor.
const PostprocessorValue &	getPostprocessorValueOldByName (const PostprocessorName &name) const
const PostprocessorValue &	getPostprocessorValueOlderByName (const PostprocessorName &name) const

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	addPostprocessorDependencyHelper (const PostprocessorName &) const
	Helper for deriving classes to override to add dependencies when a Postprocessor is requested.

Private Member Functions
const PostprocessorName &	getPostprocessorNameInternal (const std::string &param_name, const unsigned int index, const bool allow_default_value=true) const
	Internal method for getting the PostprocessorName associated with a paremeter.
bool	isDefaultPostprocessorValueByName (const PostprocessorName &name) const
PostprocessorValue	getDefaultPostprocessorValueByName (const PostprocessorName &name) const
void	checkParam (const std::string &param_name, const unsigned int index=std::numeric_limits< unsigned int >::max()) const
	Checks the parameters relating to a Postprocessor.
bool	postprocessorsAdded () const
const PostprocessorValue &	getPostprocessorValueInternal (const std::string &param_name, unsigned int index, std::size_t t_index) const
	Internal methods for getting Postprocessor values.
const PostprocessorValue &	getPostprocessorValueByNameInternal (const PostprocessorName &name, std::size_t t_index) const

Private Attributes
const MooseObject &	_ppi_moose_object
	The MooseObject that uses this interface.
const InputParameters &	_ppi_params
	PostprocessorInterface Parameters.
const FEProblemBase &	_ppi_feproblem
	Reference the the FEProblemBase class.
std::map< PostprocessorName, std::unique_ptr< PostprocessorValue > >	_default_values
	Holds the default postprocessor values that are requested (key is PostprocessorName)

Detailed Description

Interface class for classes which interact with Postprocessors.

Provides the getPostprocessorValueXYZ() and related interfaces.

Definition at line 34 of file PostprocessorInterface.h.

Constructor & Destructor Documentation

PostprocessorInterface() [1/3]

PostprocessorInterface::PostprocessorInterface

(

const MooseObject *

moose_object

)

Definition at line 21 of file PostprocessorInterface.C.

  : _ppi_moose_object(*moose_object),
    _ppi_params(_ppi_moose_object.parameters()),
    _ppi_feproblem(*_ppi_params.getCheckedPointerParam<FEProblemBase *>("_fe_problem_base"))
{
}

PostprocessorInterface() [2/3]

PostprocessorInterface::PostprocessorInterface

(

const FEProblemBase *

problem

)

Definition at line 28 of file PostprocessorInterface.C.

  : _ppi_moose_object(*problem),
    _ppi_params(_ppi_moose_object.parameters()),
    _ppi_feproblem(*problem)
{
}

PostprocessorInterface() [3/3]

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

Special constructor used for Kokkos functor copy during parallel dispatch.

Definition at line 36 of file PostprocessorInterface.C.

  : _ppi_moose_object(object._ppi_moose_object),
    _ppi_params(object._ppi_params),
    _ppi_feproblem(object._ppi_feproblem)
{
}

Member Function Documentation

addPostprocessorDependencyHelper()

virtual void PostprocessorInterface::addPostprocessorDependencyHelper ( const PostprocessorName &  ) const

inlineprotectedvirtual

Helper for deriving classes to override to add dependencies when a Postprocessor is requested.

Reimplemented in UserObjectBase, AuxKernelBase, and InitialConditionBase.

Definition at line 149 of file PostprocessorInterface.h.

{}

Referenced by getPostprocessorValueByNameInternal().

checkParam()

void PostprocessorInterface::checkParam ( const std::string &  param_name, const unsigned int  index = std::numeric_limits<unsigned int>::max()  ) const

private

Checks the parameters relating to a Postprocessor.

If index is not set, index checking is not performed.

Definition at line 149 of file PostprocessorInterface.C.

{
  const bool check_index = index != std::numeric_limits<unsigned int>::max();
 
  if (!_ppi_params.isParamValid(param_name))
    _ppi_moose_object.mooseError(
        "When getting a Postprocessor, failed to get a parameter with the name \"",
        param_name,
        "\".",
        "\n\nKnown parameters:\n",
        _ppi_moose_object.parameters());
 
  if (_ppi_params.isType<PostprocessorName>(param_name))
  {
    if (check_index && index > 0)
      _ppi_moose_object.paramError(param_name,
                                   "A Postprocessor was requested with index ",
                                   index,
                                   " but a single Postprocessor is coupled.");
  }
  else if (_ppi_params.isType<std::vector<PostprocessorName>>(param_name))
  {
    const auto & names = _ppi_params.get<std::vector<PostprocessorName>>(param_name);
    if (check_index && names.size() <= index)
      _ppi_moose_object.paramError(param_name,
                                   "A Postprocessor was requested with index ",
                                   index,
                                   " but only ",
                                   names.size(),
                                   " Postprocessors are coupled.");
  }
  else
  {
    _ppi_moose_object.mooseError(
        "Supplied parameter with name \"",
        param_name,
        "\" of type \"",
        _ppi_params.type(param_name),
        "\" is not an expected type for getting a Postprocessor.\n\n",
        "Allowed types are \"PostprocessorName\" and \"std::vector<PostprocessorName>\".");
  }
}

Referenced by coupledPostprocessors(), and getPostprocessorNameInternal().

coupledPostprocessors()

std::size_t PostprocessorInterface::coupledPostprocessors

(

const std::string &

param_name

)

const

Returns number of Postprocessors coupled under parameter name.

Parameters

param_name

The name of the Postprocessor parameter

Returns

Number of coupled post-processors, 1 if it's a single

Definition at line 139 of file PostprocessorInterface.C.

{
  checkParam(param_name);
 
  if (_ppi_params.isType<PostprocessorName>(param_name))
    return 1;
  return _ppi_params.get<std::vector<PostprocessorName>>(param_name).size();
}

Referenced by FunctionValuePostprocessor::FunctionValuePostprocessor().

getDefaultPostprocessorValueByName()

PostprocessorValue PostprocessorInterface::getDefaultPostprocessorValueByName ( const PostprocessorName &  name ) const

private

Returns

The default value stored in the PostprocessorName name.

Definition at line 106 of file PostprocessorInterface.C.

{
  mooseAssert(isDefaultPostprocessorValueByName(name), "Not a default value");
 
  Real real_value = -std::numeric_limits<Real>::max();
  std::istringstream ss(name);
  ss >> real_value;
  return real_value;
}

Referenced by getPostprocessorValueInternal().

getPostprocessorName()

const PostprocessorName & PostprocessorInterface::getPostprocessorName	(	const std::string &	param_name,
		const unsigned int	index = 0
	)		const

Get the name of a postprocessor.

This can only be used if the postprocessor parameter does not have a default value set (see isDefaultPostprocessorValue()), in which case the "name" is actually the default value.

Parameters

param_name	The name of the Postprocessor parameter
index	The index of the Postprocessor

Returns

The name of the given Postprocessor

Definition at line 195 of file PostprocessorInterface.C.

{
  return getPostprocessorNameInternal(param_name, index, /* allow_default_value = */ false);
}

Referenced by EigenKernel::EigenKernel().

getPostprocessorNameInternal()

const PostprocessorName & PostprocessorInterface::getPostprocessorNameInternal ( const std::string &  param_name, const unsigned int  index, const bool  allow_default_value = true  ) const

private

Internal method for getting the PostprocessorName associated with a paremeter.

Needed in order to allow the return of a name that is a default value.

Definition at line 202 of file PostprocessorInterface.C.

{
  checkParam(param_name, index);
 
  const auto & name = _ppi_params.isType<PostprocessorName>(param_name)
                          ? _ppi_params.get<PostprocessorName>(param_name)
                          : _ppi_params.get<std::vector<PostprocessorName>>(param_name)[index];
 
  if (!allow_default_value && isDefaultPostprocessorValueByName(name))
  {
    std::stringstream oss;
    oss << "Cannot get the name associated with PostprocessorName parameter \"" << param_name
        << "\"";
    if (index)
      oss << " at index " << index;
    oss << ",\nbecause said parameter is a default Postprocessor value.";
    _ppi_moose_object.paramError(param_name, oss.str());
  }
 
  return name;
}

Referenced by getPostprocessorName(), getPostprocessorValueInternal(), hasPostprocessor(), and isDefaultPostprocessorValue().

getPostprocessorValue()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValue	(	const std::string &	param_name,
		const unsigned int	index = 0
	)		const

doco-normal-methods-begin Retrieve the value of a Postprocessor or one of it's old or older values

Parameters

param_name	The name of the Postprocessor parameter (see below)
index	The index of the Postprocessor

Returns

A reference to the desired value

The name required by this method is the name that is hard-coded into your source code. For example, if you have a Kernel that requires a Postprocessor you may have an input file with "pp = my_pp", this function requires the "pp" name as input (see .../moose_test/functions/PostprocessorFunction.C)

see getPostprocessorValueByName getPostprocessorValueOldByName getPostprocessorValueOlderByName

Definition at line 46 of file PostprocessorInterface.C.

{
  return getPostprocessorValueInternal(param_name, index, /* t_index = */ 0);
}

Referenced by EigenKernel::EigenKernel(), FunctionValuePostprocessor::FunctionValuePostprocessor(), LinearCombinationPostprocessor::LinearCombinationPostprocessor(), and ParsedPostprocessor::ParsedPostprocessor().

getPostprocessorValueByName()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValueByName ( const PostprocessorName &  name ) const

virtual

Retrieve the value of the Postprocessor.

Parameters

name	Postprocessor name (see below)

Returns

A reference to the desired value

The name required by this method is the name defined in the input file. For example, if you have a Kernel that requires a Postprocessor you may have an input file with "pp = my_pp", this method requires the "my_pp" name as input (see .../moose_test/functions/PostprocessorFunction.C)

see getPostprocessorValue getPostprocessorValueOld getPostprocessorValueOlder

Definition at line 67 of file PostprocessorInterface.C.

{
  return getPostprocessorValueByNameInternal(name, /* t_index = */ 0);
}

Referenced by EigenKernel::EigenKernel(), PIDTransientControl::execute(), IterationAdaptiveDT::IterationAdaptiveDT(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), MultiPostprocessorConvergence::MultiPostprocessorConvergence(), ParsedODEKernel::ParsedODEKernel(), PicardSolve::savePostprocessorValues(), SecantSolve::savePostprocessorValues(), SteffensenSolve::savePostprocessorValues(), SumPostprocessor::SumPostprocessor(), Terminator::Terminator(), PicardSolve::transformPostprocessors(), SecantSolve::transformPostprocessors(), SteffensenSolve::transformPostprocessors(), and VectorOfPostprocessors::VectorOfPostprocessors().

getPostprocessorValueByNameInternal()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValueByNameInternal ( const PostprocessorName &  name, std::size_t  t_index  ) const

private

Definition at line 256 of file PostprocessorInterface.C.

{
  mooseAssert(t_index < 3, "Invalid time index");
  mooseAssert(!isDefaultPostprocessorValueByName(name), "Should not be default");
 
  // If all pps have been added, we can check for existance
  if (postprocessorsAdded() && !hasPostprocessorByName(name))
    _ppi_moose_object.mooseError("A Postprocessor with the name \"", name, "\" was not found.");
 
  if (t_index == 0)
    addPostprocessorDependencyHelper(name);
 
  return _ppi_feproblem.getReporterData().getReporterValue<PostprocessorValue>(
      PostprocessorReporterName(name), _ppi_moose_object, REPORTER_MODE_ROOT, t_index);
}

Referenced by getPostprocessorValueByName(), getPostprocessorValueInternal(), getPostprocessorValueOldByName(), and getPostprocessorValueOlderByName().

getPostprocessorValueInternal()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValueInternal ( const std::string &  param_name, unsigned int  index, std::size_t  t_index  ) const

private

Internal methods for getting Postprocessor values.

Definition at line 228 of file PostprocessorInterface.C.

{
  const auto & name = getPostprocessorNameInternal(param_name, index);
 
  // If the Postprocessor is a default value (either set by addParam or set to a constant
  // value by the user in input/an action), we covert the name to a value, store said
  // value locally, and return it so that it fits in with the rest of the interface
  // (needing a reference to a value)
  if (isDefaultPostprocessorValueByName(name))
  {
    const auto value = getDefaultPostprocessorValueByName(name);
    const auto & value_ref =
        *_default_values.emplace(name, std::make_unique<PostprocessorValue>(value))
             .first->second; // first is inserted pair, second is value in pair
    mooseAssert(value == value_ref, "Inconsistent default value");
    return value_ref;
  }
  // If not a default and all pps have been added, we check check for existance
  else if (postprocessorsAdded() && !hasPostprocessorByName(name))
    _ppi_moose_object.paramError(
        param_name, "A Postprocessor with the name \"", name, "\" was not found.");
 
  return getPostprocessorValueByNameInternal(name, t_index);
}

Referenced by getPostprocessorValue(), getPostprocessorValueOld(), and getPostprocessorValueOlder().

getPostprocessorValueOld()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValueOld	(	const std::string &	param_name,
		const unsigned int	index = 0
	)		const

Definition at line 53 of file PostprocessorInterface.C.

{
  return getPostprocessorValueInternal(param_name, index, /* t_index = */ 1);
}

getPostprocessorValueOldByName()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValueOldByName

(

const PostprocessorName &

name

)

const

Definition at line 73 of file PostprocessorInterface.C.

{
  return getPostprocessorValueByNameInternal(name, /* t_index = */ 1);
}

Referenced by EigenKernel::EigenKernel().

getPostprocessorValueOlder()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValueOlder	(	const std::string &	param_name,
		const unsigned int	index = 0
	)		const

Definition at line 60 of file PostprocessorInterface.C.

{
  return getPostprocessorValueInternal(param_name, index, /* t_index = */ 2);
}

getPostprocessorValueOlderByName()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValueOlderByName

(

const PostprocessorName &

name

)

const

Definition at line 79 of file PostprocessorInterface.C.

{
  return getPostprocessorValueByNameInternal(name, /* t_index = */ 2);
}

hasPostprocessor()

bool PostprocessorInterface::hasPostprocessor	(	const std::string &	param_name,
		const unsigned int	index = 0
	)		const

Determine if the Postprocessor data exists.

Parameters

param_name	The name of the Postprocessor parameter
index	The index of the Postprocessor

Returns

True if the Postprocessor exists

See also

hasPostprocessorByName getPostprocessorValue

Definition at line 117 of file PostprocessorInterface.C.

{
  if (!postprocessorsAdded())
    _ppi_moose_object.mooseError(
        "Cannot call hasPostprocessor() until all Postprocessors have been constructed.");
 
  return hasPostprocessorByName(getPostprocessorNameInternal(param_name, index));
}

hasPostprocessorByName()

bool PostprocessorInterface::hasPostprocessorByName

(

const PostprocessorName &

name

)

const

Determine if the Postprocessor data exists.

Parameters

name	The name of the Postprocessor

Returns

True if the Postprocessor exists

See also

hasPostprocessor getPostprocessorValueByName

Definition at line 128 of file PostprocessorInterface.C.

{
  if (!postprocessorsAdded())
    _ppi_moose_object.mooseError(
        "Cannot call hasPostprocessorByName() until all Postprocessors have been constructed.");
 
  return _ppi_feproblem.getReporterData().hasReporterValue<PostprocessorValue>(
      PostprocessorReporterName(name));
}

Referenced by getPostprocessorValueByNameInternal(), getPostprocessorValueInternal(), hasPostprocessor(), AdvancedOutput::initShowHideLists(), Exodus::outputReporters(), and TableOutput::outputReporters().

isDefaultPostprocessorValue()

bool PostprocessorInterface::isDefaultPostprocessorValue	(	const std::string &	param_name,
		const unsigned int	index = 0
	)		const

Determine whether or not the Postprocessor is a default value.

A default value is when the value is either the value set by addParam, or is a user-set value in input instead of a name to a postprocessor.

Parameters

param_name	The name of the Postprocessor parameter
index	The index of the postprocessor

Returns

True if the Postprocessor is a default value, false if the Postprocessor is the name of a Postprocessor

Definition at line 85 of file PostprocessorInterface.C.

{
  return isDefaultPostprocessorValueByName(getPostprocessorNameInternal(param_name, index));
}

Referenced by EigenKernel::EigenKernel().

isDefaultPostprocessorValueByName()

bool PostprocessorInterface::isDefaultPostprocessorValueByName ( const PostprocessorName &  name ) const

private

Returns

True if the PostprocessorName name repesents a default value: the name converts to a value (set by addParam or set via input), and a Postprocessor does not exist with the same name (we do allow Postprocessors with numbered names...)

Definition at line 92 of file PostprocessorInterface.C.

{
  // We do allow actual Postprocessor objects to have names that will succeed in being
  // represented as a double... so if the name does actually exist as a PP, it's not a default
  if (_ppi_feproblem.getReporterData().hasReporterValue<PostprocessorValue>(
          PostprocessorReporterName(name)))
    return false;
 
  std::istringstream ss(name);
  Real real_value = -std::numeric_limits<Real>::max();
  return (ss >> real_value && ss.eof());
}

Referenced by getDefaultPostprocessorValueByName(), getPostprocessorNameInternal(), getPostprocessorValueByNameInternal(), getPostprocessorValueInternal(), and isDefaultPostprocessorValue().

postprocessorsAdded()

bool PostprocessorInterface::postprocessorsAdded ( ) const

private

Returns

True if all pps have been added (the task associated with adding them is complete)

Definition at line 274 of file PostprocessorInterface.C.

{
  return _ppi_feproblem.getMooseApp().actionWarehouse().isTaskComplete("add_postprocessor");
}

Referenced by getPostprocessorValueByNameInternal(), getPostprocessorValueInternal(), hasPostprocessor(), and hasPostprocessorByName().

validParams()

InputParameters PostprocessorInterface::validParams ( )

static

Definition at line 16 of file PostprocessorInterface.C.

{
  return emptyInputParameters();
}

Referenced by Convergence::validParams(), FVInterfaceKernel::validParams(), and MFEMObject::validParams().

Member Data Documentation

_default_values

std::map<PostprocessorName, std::unique_ptr<PostprocessorValue> > PostprocessorInterface::_default_values

mutableprivate

Holds the default postprocessor values that are requested (key is PostprocessorName)

Definition at line 162 of file PostprocessorInterface.h.

Referenced by getPostprocessorValueInternal().

_ppi_feproblem

const FEProblemBase& PostprocessorInterface::_ppi_feproblem

private

Reference the the FEProblemBase class.

Definition at line 159 of file PostprocessorInterface.h.

Referenced by getPostprocessorValueByNameInternal(), hasPostprocessorByName(), isDefaultPostprocessorValueByName(), and postprocessorsAdded().

_ppi_moose_object

const MooseObject& PostprocessorInterface::_ppi_moose_object

private

The MooseObject that uses this interface.

Definition at line 153 of file PostprocessorInterface.h.

Referenced by checkParam(), getPostprocessorNameInternal(), getPostprocessorValueByNameInternal(), getPostprocessorValueInternal(), hasPostprocessor(), and hasPostprocessorByName().

_ppi_params

const InputParameters& PostprocessorInterface::_ppi_params

private

PostprocessorInterface Parameters.

Definition at line 156 of file PostprocessorInterface.h.

Referenced by checkParam(), coupledPostprocessors(), and getPostprocessorNameInternal().

---

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

• include/interfaces/PostprocessorInterface.h
• src/interfaces/PostprocessorInterface.C