StochasticResults Class Reference

A tool for output Sampler data. More...

#include <StochasticResults.h>

Inheritance diagram for StochasticResults:

Public Member Functions
	StochasticResults (const InputParameters &parameters)
virtual void	initialize () override
virtual void	finalize () override
virtual void	execute () override
void	setCurrentLocalVectorPostprocessorValue (const std::string &vector_name, const VectorPostprocessorValue &&current)
void	init (Sampler &_sampler)
	DEPRECATED Initialize storage based on the Sampler returned by the SamplerTransientMultiApp or SamplerFullSolveMultiApp. More...

Static Public Member Functions
static InputParameters	validParams ()

Protected Attributes
std::vector< StochasticResultsData >	_sample_vectors
	Storage for declared vectors. More...
const MooseEnum	_parallel_type
	Parallel operation mode. More...
const processor_id_type	_output_distributed_rank
	The rank data to output if parallel type is distributed. More...

Detailed Description

A tool for output Sampler data.

Definition at line 35 of file StochasticResults.h.

Constructor & Destructor Documentation

StochasticResults()

StochasticResults::StochasticResults

(

const InputParameters &

parameters

)

Definition at line 54 of file StochasticResults.C.

  : GeneralVectorPostprocessor(parameters),
    SamplerInterface(this),
    _parallel_type(getParam<MooseEnum>("parallel_type")),
    _output_distributed_rank(getParam<processor_id_type>("output_distributed_rank"))
{
 
  if (_output_distributed_rank != Moose::INVALID_PROCESSOR_ID)
  {
    if (_parallel_type == "replicated")
      paramError("output_distributed_rank",
                 "The output rank cannot be used with 'parallel_type' set to replicated.");
    else if (_output_distributed_rank >= n_processors())
      paramError("output_distributed_rank",
                 "The supplied value is greater than the number of available processors: ",
                 _output_distributed_rank);
  }
  else
  {
    if ((_parallel_type == "DISTRIBUTED") && (getOutputs().count("none") == 0) &&
        (n_processors() > 1))
      paramWarning("parallel_type",
                   "The parallel_type was set to DISTRIBUTED and output is enabled for the object, "
                   "when running in parallel the results output will only contain the data on the "
                   "root processor. Output can be disabled by setting 'outputs = none' in the "
                   "input block. If output is desired the 'output_distributed_rank' can be set.");
  }
 
  if (isParamValid("samplers"))
    for (const SamplerName & name : getParam<std::vector<SamplerName>>("samplers"))
    {
      Sampler & sampler = getSamplerByName(name);
      _sample_vectors.emplace_back(sampler.name(), &declareVector(sampler.name()));
    }
}

Member Function Documentation

execute()

virtual void StochasticResults::execute ( )

inlineoverridevirtual

Definition at line 43 of file StochasticResults.h.

{}

finalize()

void StochasticResults::finalize ( )

overridevirtual

Definition at line 100 of file StochasticResults.C.

{
  if (_parallel_type == "REPLICATED")
  {
    for (auto & data : _sample_vectors)
      _communicator.gather(0, data.current);
  }
 
  else if (_output_distributed_rank != 0 && _output_distributed_rank != Moose::INVALID_PROCESSOR_ID)
  {
    if (processor_id() == _output_distributed_rank)
      for (auto & data : _sample_vectors)
        _communicator.send(0, data.current);
 
    else if (processor_id() == 0)
      for (auto & data : _sample_vectors)
        _communicator.receive(_output_distributed_rank, data.current);
  }
 
  for (auto & data : _sample_vectors)
  {
    data.vector->insert(data.vector->end(), data.current.begin(), data.current.end());
    data.current.clear();
  }
}

init()

void StochasticResults::init

(

Sampler &

_sampler

)

DEPRECATED Initialize storage based on the Sampler returned by the SamplerTransientMultiApp or SamplerFullSolveMultiApp.

Parameters

sampler

The Sampler associated with the MultiApp that this VPP is working with.

This an internal method that is called by the SamplerPostprocessorTransfer, it should not be called otherwise.

Definition at line 141 of file StochasticResults.C.

{
  if (!isParamValid("samplers"))
  {
    paramWarning("samplers",
                 "Support for the 'StochasticResults' objects without the 'samplers' input "
                 "parameter is being removed, please update your input file(s).");
    _sample_vectors.emplace_back(sampler.name(), &declareVector(sampler.name()));
  }
}

Referenced by SamplerPostprocessorTransfer::initialSetup().

initialize()

void StochasticResults::initialize ( )

overridevirtual

Definition at line 91 of file StochasticResults.C.

{
  // Clear any existing data, unless the complete history is desired
  if (!containsCompleteHistory())
    for (auto & data : _sample_vectors)
      data.vector->clear();
}

setCurrentLocalVectorPostprocessorValue()

void StochasticResults::setCurrentLocalVectorPostprocessorValue	(	const std::string &	vector_name,
		const VectorPostprocessorValue &&	current
	)

Definition at line 127 of file StochasticResults.C.

{
  mooseAssert(!hasVectorPostprocessorByName(name),
              "The supplied name must be a valid vector postprocessor name.");
  auto data_ptr = std::find_if(_sample_vectors.begin(),
                               _sample_vectors.end(),
                               [&name](StochasticResultsData & data) { return data.name == name; });
 
  data_ptr->current = current;
}

Referenced by SamplerPostprocessorTransfer::execute(), and SamplerPostprocessorTransfer::finalizeFromMultiapp().

validParams()

InputParameters StochasticResults::validParams ( )

static

Definition at line 27 of file StochasticResults.C.

{
  InputParameters params = GeneralVectorPostprocessor::validParams();
  params.addClassDescription(
      "Storage container for stochastic simulation results coming from a Postprocessor.");
  params += SamplerInterface::validParams();
 
  params.addParam<std::vector<SamplerName>>("samplers",
                                            "A list of sampler names of associated data.");
 
  MooseEnum parallel_type("REPLICATED DISTRIBUTED", "REPLICATED");
  params.addParam<MooseEnum>(
      "parallel_type",
      parallel_type,
      "Specify if the stored data vector is replicated or distributed across processors.");
 
  params.addParam<processor_id_type>(
      "output_distributed_rank",
      Moose::INVALID_PROCESSOR_ID,
      "When 'parallel_type = DISTRIBUTED' set this to copy the data from the specified processor "
      "for output. This is mainly for testing since the data from that rank will override the data "
      "on the root process.");
 
  params.set<bool>("_is_broadcast") = false;
  return params;
}

Member Data Documentation

_output_distributed_rank

const processor_id_type StochasticResults::_output_distributed_rank

protected

The rank data to output if parallel type is distributed.

Definition at line 82 of file StochasticResults.h.

Referenced by finalize(), and StochasticResults().

_parallel_type

const MooseEnum StochasticResults::_parallel_type

protected

Parallel operation mode.

Definition at line 79 of file StochasticResults.h.

Referenced by finalize(), and StochasticResults().

_sample_vectors

std::vector<StochasticResultsData> StochasticResults::_sample_vectors

protected

Storage for declared vectors.

Definition at line 76 of file StochasticResults.h.

Referenced by finalize(), init(), initialize(), setCurrentLocalVectorPostprocessorValue(), and StochasticResults().

---

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

• stochastic_tools/include/vectorpostprocessors/StochasticResults.h
• stochastic_tools/src/vectorpostprocessors/StochasticResults.C