www.mooseframework.org
VectorPostprocessor.C
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://www.mooseframework.org
3 //*
4 //* All rights reserved, see COPYRIGHT for full restrictions
5 //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6 //*
7 //* Licensed under LGPL 2.1, please see LICENSE for details
8 //* https://www.gnu.org/licenses/lgpl-2.1.html
9 
10 // MOOSE includes
11 #include "VectorPostprocessor.h"
12 #include "SubProblem.h"
13 #include "Conversion.h"
14 #include "UserObject.h"
15 #include "FEProblem.h"
16 
19 {
21  params += OutputInterface::validParams();
22  params.addParam<bool>("contains_complete_history",
23  false,
24  "Set this flag to indicate that the values in all vectors declared by this "
25  "VPP represent a time history (e.g. with each invocation, new values are "
26  "added and old values are never removed). This changes the output so that "
27  "only a single file is output and updated with each invocation");
28 
29  // VPPs can set this to true if their resulting vectors are naturally replicated in parallel
30  // setting this to false will keep MOOSE from unnecessarily broadcasting those vectors
31  params.addPrivateParam<bool>("_auto_broadcast", true);
32 
33  // VPPs can operate in "distributed" mode, which disables the automatic broadcasting
34  // and results in an individual file per processor if CSV output is enabled
35  MooseEnum parallel_type("DISTRIBUTED REPLICATED", "REPLICATED");
36  params.addParam<MooseEnum>(
37  "parallel_type",
38  parallel_type,
39  "Set how the data is represented within the VectorPostprocessor (VPP); 'distributed' "
40  "indicates that data within the VPP is distributed and no auto communication is performed, "
41  "this setting will result in parallel output within the CSV output; 'replicated' indicates "
42  "that the data within the VPP is correct on processor 0, the data will automatically be "
43  "broadcast to all processors unless the '_auto_broadcast' param is set to false within the "
44  "validParams function.");
45 
46  params.addParamNamesToGroup("outputs", "Advanced");
47  params.registerBase("VectorPostprocessor");
48  return params;
49 }
50 
52  : OutputInterface(moose_object->parameters()),
53  _vpp_name(MooseUtils::shortName(moose_object->parameters().get<std::string>("_object_name"))),
54  _vpp_fe_problem(
55  *moose_object->parameters().getCheckedPointerParam<FEProblemBase *>("_fe_problem_base")),
56  _parallel_type(moose_object->parameters().get<MooseEnum>("parallel_type")),
57  _vpp_moose_object(*moose_object),
58  _vpp_tid(moose_object->parameters().isParamValid("_tid")
59  ? moose_object->parameters().get<THREAD_ID>("_tid")
60  : 0),
61  _contains_complete_history(moose_object->parameters().get<bool>("contains_complete_history")),
62  _is_distributed(_parallel_type == "DISTRIBUTED"),
63  _is_broadcast(_is_distributed || !moose_object->parameters().get<bool>("_auto_broadcast"))
64 {
65 }
66 
68 VectorPostprocessor::declareVector(const std::string & vector_name)
69 {
70  _vector_names.insert(vector_name);
71 
72  if (_vpp_tid)
73  return _thread_local_vectors.emplace(vector_name, VectorPostprocessorValue()).first->second;
74 
75  // _is_broadcast = true (_auto_broadcast = false) then data is produced in a replicated manner
77  if (_is_broadcast)
79  if (_is_distributed)
81 
86 }
87 
88 const std::set<std::string> &
90 {
91  return _vector_names;
92 }
93 
94 const ReporterMode REPORTER_MODE_VPP_SCATTER("VPP_SCATTER");
95 
96 template <typename T>
98  const MooseObject & producer,
99  ReporterState<T> & state)
100  : ReporterGeneralContext<T>(other, producer, state)
101 {
102 }
103 
104 template <typename T>
105 void
107 {
109 
110  const auto & consumer_modes = this->state().getConsumers();
111  auto func = [](const std::pair<ReporterMode, const MooseObject *> & mode_pair)
112  { return mode_pair.first == REPORTER_MODE_VPP_SCATTER; };
113  if (std::find_if(consumer_modes.begin(), consumer_modes.end(), func) != consumer_modes.end())
114  {
115  const T & value = this->state().value();
116  if (this->processor_id() == 0 && value.size() != this->n_processors())
117  mooseError("The VectorPostprocessor value to be scatter has a length of ",
118  value.size(),
119  "; it must be the same length as the number of processors (",
120  this->n_processors(),
121  ").");
122 
123  this->comm().scatter(value, _scatter_value);
124  }
125 }
126 
127 template <typename T>
128 void
130 {
132  _scatter_value_old = _scatter_value;
133 }
134 
135 template <typename T>
138 {
139  return _scatter_value;
140 }
141 
142 template <typename T>
145 {
146  return _scatter_value_old;
147 }
148 
149 // Explicit instantiation
virtual void finalize() override
Perform automatic parallel communication based on the producer/consumer modes.
A special version of RestartableData to aid in storing Reporter values.
static InputParameters validParams()
void addPrivateParam(const std::string &name, const T &value)
These method add a parameter to the InputParameters object which can be retrieved like any other para...
T & declareReporterValue(const ReporterName &reporter_name, const ReporterMode &mode, const MooseObject &producer, Args &&... args)
Method for returning a writable reference to the current Reporter value.
Definition: ReporterData.h:391
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:284
const THREAD_ID _vpp_tid
const ReporterMode REPORTER_MODE_ROOT
T * get(const std::unique_ptr< T > &u)
The MooseUtils::get() specializations are used to support making forwards-compatible code changes fro...
Definition: MooseUtils.h:1147
A class to provide an common interface to objects requiring "outputs" option.
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
const ScatterVectorPostprocessorValue & getScatterValueOld() const
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
std::string shortName(const std::string &name)
Function for stripping name after the file / in parser block.
Definition: MooseUtils.C:598
A ReporterName that represents a VectorPostprocessor.
Definition: ReporterName.h:143
void registerBase(const std::string &value)
This method must be called from every base "Moose System" to create linkage with the Action System...
const ReporterData & getReporterData() const
Provides const access the ReporterData object.
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
Every object that can be built by the factory should be derived from this class.
Definition: MooseObject.h:33
const MooseObject & _vpp_moose_object
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:31
const ReporterMode REPORTER_MODE_DISTRIBUTED
VectorPostprocessorValue & declareVector(const std::string &vector_name)
Register a new vector to fill up.
std::map< std::string, VectorPostprocessorValue > _thread_local_vectors
VectorPostprocessorContext(const libMesh::ParallelObject &other, const MooseObject &producer, ReporterState< T > &state)
virtual void copyValuesBack() override
Called by FEProblemBase::advanceState via ReporterData.
FEProblemBase & _vpp_fe_problem
The FEProblemBase.
std::vector< Real > VectorPostprocessorValue
Definition: MooseTypes.h:192
Real ScatterVectorPostprocessorValue
Definition: MooseTypes.h:193
virtual void copyValuesBack() override
Called by FEProblemBase::advanceState via ReporterData.
static InputParameters validParams()
const ReporterMode REPORTER_MODE_VPP_SCATTER("VPP_SCATTER")
std::set< std::string > _vector_names
void addParam(const std::string &name, const S &value, const std::string &doc_string)
These methods add an option parameter and a documentation string to the InputParameters object...
const ReporterMode REPORTER_MODE_REPLICATED
MooseEnumItem that automatically creates the ID and doesn&#39;t allow the ID to be assigned.
Definition: ReporterMode.h:44
const std::set< std::string > & getVectorNames() const
Return the names of the vectors associated with this object.
const ScatterVectorPostprocessorValue & getScatterValue() const
VectorPostprocessor(const MooseObject *moose_object)
unsigned int THREAD_ID
Definition: MooseTypes.h:198
void addParamNamesToGroup(const std::string &space_delim_names, const std::string group_name)
This method takes a space delimited list of parameter names and adds them to the specified group name...
static InputParameters validParams()
Definition: UserObject.C:18
const std::string _vpp_name
The name of the VectorPostprocessor.
virtual void finalize() override
Perform automatic parallel communication based on the producer/consumer modes.