VectorPostprocessor Class Reference

Base class for Postprocessors that produce a vector of values. More...

#include <VectorPostprocessor.h>

Inheritance diagram for VectorPostprocessor:

Public Member Functions
	VectorPostprocessor (const MooseObject *moose_object)
virtual	~VectorPostprocessor ()=default
std::string	PPName () const
	Returns the name of the VectorPostprocessor. More...
bool	containsCompleteHistory () const
	Return whether or not this VectorPostprocessor contains complete history. More...
bool	isDistributed () const
	Return true if the VPP is operating in distributed mode. More...
const std::set< std::string > &	getVectorNames () const
	Return the names of the vectors associated with this object. More...
void	buildOutputHideVariableList (std::set< std::string > variable_names)
	Builds hide lists for output objects NOT listed in the 'outputs' parameter. More...
const std::set< OutputName > &	getOutputs ()
	Get the list of output objects that this class is restricted. More...

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

Protected Member Functions
VectorPostprocessorValue &	declareVector (const std::string &vector_name)
	Register a new vector to fill up. More...
std::string	deduceFunctorName (const std::string &name) const
	Small helper to look up a functor name through the input parameter keys. More...
template<typename T >
const Moose::Functor< T > &	getFunctor (const std::string &name)
	Retrieves a functor from the subproblem. More...
template<typename T >
const Moose::Functor< T > &	getFunctor (const std::string &name, THREAD_ID tid)
	Retrieves a functor from the subproblem. More...
template<typename T >
const Moose::Functor< T > &	getFunctor (const std::string &name, SubProblem &subproblem)
	Retrieves a functor from the passed-in subproblem. More...
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. More...
bool	isFunctor (const std::string &name) const
	Checks the subproblem for the given functor. More...
bool	isFunctor (const std::string &name, const SubProblem &subproblem) const
	Checks the passed-in subproblem for the given functor. More...
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. More...
template<typename T >
void	checkFunctorSupportsSideIntegration (const std::string &name, bool qp_integration)
	Throws error if the functor does not support the requested side integration. More...

Protected Attributes
const std::string	_vpp_name
	The name of the VectorPostprocessor. More...
FEProblemBase &	_vpp_fe_problem
	The FEProblemBase. More...
const MooseEnum &	_parallel_type
	DISTRIBUTED or REPLICATED. More...

Private Attributes
const MooseObject &	_vpp_moose_object
const THREAD_ID	_vpp_tid
const bool	_contains_complete_history
const bool	_is_distributed
const bool	_is_broadcast
std::map< std::string, VectorPostprocessorValue >	_thread_local_vectors
std::set< std::string >	_vector_names

Friends
class	SamplerBase

Detailed Description

Base class for Postprocessors that produce a vector of values.

Definition at line 34 of file VectorPostprocessor.h.

Constructor & Destructor Documentation

VectorPostprocessor()

VectorPostprocessor::VectorPostprocessor

(

const MooseObject *

moose_object

)

Definition at line 52 of file VectorPostprocessor.C.

  : OutputInterface(moose_object->parameters()),
    NonADFunctorInterface(moose_object),
    _vpp_name(MooseUtils::shortName(moose_object->name())),
    _vpp_fe_problem(
        *moose_object->parameters().getCheckedPointerParam<FEProblemBase *>("_fe_problem_base")),
    _parallel_type(moose_object->parameters().get<MooseEnum>("parallel_type")),
    _vpp_moose_object(*moose_object),
    _vpp_tid(moose_object->parameters().isParamValid("_tid")
                 ? moose_object->parameters().get<THREAD_ID>("_tid")
                 : 0),
    _contains_complete_history(moose_object->parameters().get<bool>("contains_complete_history")),
    _is_distributed(_parallel_type == "DISTRIBUTED"),
    _is_broadcast(_is_distributed || !moose_object->parameters().get<bool>("_auto_broadcast"))
{
}

~VectorPostprocessor()

virtual VectorPostprocessor::~VectorPostprocessor ( )

virtualdefault

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 61 of file OutputInterface.C.

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

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

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 236 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.");
  }
}

containsCompleteHistory()

bool VectorPostprocessor::containsCompleteHistory ( ) const

inline

Return whether or not this VectorPostprocessor contains complete history.

Definition at line 51 of file VectorPostprocessor.h.

Referenced by SamplerBase::finalize(), ElementMaterialSampler::initialize(), SamplerBase::initialize(), and CSV::output().

{ return _contains_complete_history; }

declareVector()

VectorPostprocessorValue & VectorPostprocessor::declareVector ( const std::string &  vector_name )

protected

Register a new vector to fill up.

Definition at line 70 of file VectorPostprocessor.C.

Referenced by ConstantVectorPostprocessor::ConstantVectorPostprocessor(), CSVReaderVectorPostprocessor::CSVReaderVectorPostprocessor(), ElementMaterialSampler::ElementMaterialSampler(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), HistogramVectorPostprocessor::initialSetup(), LeastSquaresFit::LeastSquaresFit(), LeastSquaresFitHistory::LeastSquaresFitHistory(), MeshDivisionFunctorReductionVectorPostprocessor::MeshDivisionFunctorReductionVectorPostprocessor(), SamplerBase::setupVariables(), SidesetInfoVectorPostprocessor::SidesetInfoVectorPostprocessor(), SpatialAverageBase::SpatialAverageBase(), and WorkBalance::WorkBalance().

{
  _vector_names.insert(vector_name);

  if (_vpp_tid)
    return _thread_local_vectors.emplace(vector_name, VectorPostprocessorValue()).first->second;

  // _is_broadcast = true (_auto_broadcast = false) then data is produced in a replicated manner
  ReporterMode mode = REPORTER_MODE_ROOT;
  if (_is_broadcast)
    mode = REPORTER_MODE_REPLICATED;
  if (_is_distributed)
    mode = REPORTER_MODE_DISTRIBUTED;

  return _vpp_fe_problem.getReporterData(ReporterData::WriteKey())
      .declareReporterValue<VectorPostprocessorValue,
                            VectorPostprocessorContext<VectorPostprocessorValue>>(
          VectorPostprocessorReporterName(_vpp_name, vector_name), mode, _vpp_moose_object);
}

deduceFunctorName() [1/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 28 of file FunctorInterface.C.

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

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

deduceFunctorName() [2/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 60 of file FunctorInterface.C.

{
  return deduceFunctorName(name, _fi_params);
}

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, not the actual name of the functor created in the input file

Returns

The functor

Definition at line 200 of file FunctorInterface.h.

Referenced by MaterialFunctorConverterTempl< T >::MaterialFunctorConverterTempl().

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

getFunctor() [2/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, 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 192 of file FunctorInterface.h.

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

getFunctor() [3/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, 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 185 of file FunctorInterface.h.

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

getFunctor() [4/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, 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 176 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);
}

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 94 of file OutputInterface.C.

{
  return _oi_outputs;
}

getVectorNames()

const std::set< std::string > & VectorPostprocessor::getVectorNames

(

)

const

Return the names of the vectors associated with this object.

Definition at line 91 of file VectorPostprocessor.C.

Referenced by HistogramVectorPostprocessor::execute(), and HistogramVectorPostprocessor::initialSetup().

{
  return _vector_names;
}

isDistributed()

bool VectorPostprocessor::isDistributed ( ) const

inline

Return true if the VPP is operating in distributed mode.

Definition at line 56 of file VectorPostprocessor.h.

Referenced by VectorPostprocessorInterface::isVectorPostprocessorDistributedByName(), and XMLOutput::outputVectorPostprocessors().

{ return _is_distributed; }

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, not the actual name of the functor created in the input file

Returns

Whether the subproblem has the specified functor

Definition at line 113 of file FunctorInterface.C.

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

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, 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 104 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);
}

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 120 of file FunctorInterface.C.

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

{
  return {elem, correct_skewness};
}

PPName()

std::string VectorPostprocessor::PPName ( ) const

inline

Returns the name of the VectorPostprocessor.

Definition at line 46 of file VectorPostprocessor.h.

{ return _vpp_name; }

validParams()

InputParameters VectorPostprocessor::validParams ( )

static

Definition at line 18 of file VectorPostprocessor.C.

Referenced by ElementVectorPostprocessor::validParams(), SideVectorPostprocessor::validParams(), InternalSideVectorPostprocessor::validParams(), InterfaceVectorPostprocessor::validParams(), NodalVectorPostprocessor::validParams(), and GeneralVectorPostprocessor::validParams().

{
  InputParameters params = UserObject::validParams();
  params += OutputInterface::validParams();
  params += NonADFunctorInterface::validParams();
  params.addParam<bool>("contains_complete_history",
                        false,
                        "Set this flag to indicate that the values in all vectors declared by this "
                        "VPP represent a time history (e.g. with each invocation, new values are "
                        "added and old values are never removed). This changes the output so that "
                        "only a single file is output and updated with each invocation");

  // VPPs can set this to true if their resulting vectors are naturally replicated in parallel
  // setting this to false will keep MOOSE from unnecessarily broadcasting those vectors
  params.addPrivateParam<bool>("_auto_broadcast", true);

  // VPPs can operate in "distributed" mode, which disables the automatic broadcasting
  // and results in an individual file per processor if CSV output is enabled
  MooseEnum parallel_type("DISTRIBUTED REPLICATED", "REPLICATED");
  params.addParam<MooseEnum>(
      "parallel_type",
      parallel_type,
      "Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' "
      "indicates that data within the VPP is distributed and no auto communication is performed, "
      "this setting will result in parallel output within the CSV output; 'replicated' indicates "
      "that the data within the VPP is correct on processor 0, the data will automatically be "
      "broadcast to all processors unless the '_auto_broadcast' param is set to false within the "
      "validParams function.");

  params.addParamNamesToGroup("outputs", "Advanced");
  params.registerBase("VectorPostprocessor");
  return params;
}

Friends And Related Function Documentation

SamplerBase

friend class SamplerBase

friend

Definition at line 78 of file VectorPostprocessor.h.

Member Data Documentation

_contains_complete_history

const bool VectorPostprocessor::_contains_complete_history

private

Definition at line 85 of file VectorPostprocessor.h.

Referenced by containsCompleteHistory().

_is_broadcast

const bool VectorPostprocessor::_is_broadcast

private

Definition at line 89 of file VectorPostprocessor.h.

Referenced by declareVector().

_is_distributed

const bool VectorPostprocessor::_is_distributed

private

Definition at line 87 of file VectorPostprocessor.h.

Referenced by declareVector(), and isDistributed().

_parallel_type

const MooseEnum& VectorPostprocessor::_parallel_type

protected

DISTRIBUTED or REPLICATED.

Definition at line 76 of file VectorPostprocessor.h.

_thread_local_vectors

std::map<std::string, VectorPostprocessorValue> VectorPostprocessor::_thread_local_vectors

private

Definition at line 91 of file VectorPostprocessor.h.

Referenced by declareVector().

_vector_names

std::set<std::string> VectorPostprocessor::_vector_names

private

Definition at line 93 of file VectorPostprocessor.h.

Referenced by declareVector(), and getVectorNames().

_vpp_fe_problem

FEProblemBase& VectorPostprocessor::_vpp_fe_problem

protected

The FEProblemBase.

Definition at line 73 of file VectorPostprocessor.h.

Referenced by declareVector().

_vpp_moose_object

const MooseObject& VectorPostprocessor::_vpp_moose_object

private

Definition at line 81 of file VectorPostprocessor.h.

Referenced by declareVector().

_vpp_name

const std::string VectorPostprocessor::_vpp_name

protected

The name of the VectorPostprocessor.

Definition at line 70 of file VectorPostprocessor.h.

Referenced by declareVector(), and PPName().

_vpp_tid

const THREAD_ID VectorPostprocessor::_vpp_tid

private

Definition at line 83 of file VectorPostprocessor.h.

Referenced by declareVector().

---

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

• include/vectorpostprocessors/VectorPostprocessor.h
• src/vectorpostprocessors/VectorPostprocessor.C