www.mooseframework.org
OutputInterface.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 "OutputInterface.h"
12 #include "OutputWarehouse.h"
13 #include "MooseApp.h"
14 #include "ActionWarehouse.h"
15 
16 // Define input parameters
19 {
20 
22  params.addClassDescription("Interface to handle the restriction of outputs from objects");
23  params.addParam<std::vector<OutputName>>("outputs",
24  "Vector of output names where you would like "
25  "to restrict the output of variables(s) "
26  "associated with this object");
27 
28  params.addParamNamesToGroup("outputs", "Advanced");
29  std::set<std::string> reserved = {"all", "none"};
30  params.setReservedValues("outputs", reserved);
31 
32  return params;
33 }
34 
35 OutputInterface::OutputInterface(const InputParameters & parameters, bool build_list)
36  : _oi_moose_app(*parameters.getCheckedPointerParam<MooseApp *>("_moose_app")),
37  _oi_output_warehouse(_oi_moose_app.getOutputWarehouse()),
38  _oi_outputs(parameters.get<std::vector<OutputName>>("outputs").begin(),
39  parameters.get<std::vector<OutputName>>("outputs").end())
40 {
41 
42  // By default it is assumed that the variable name associated with 'outputs' is the name
43  // of the block, this is the case for Markers, Indicators, VectorPostprocessors, and
44  // Postprocessors.
45  // However, for Materials this is not the case, so the call to buildOutputHideVariableList must be
46  // disabled, the build_list allows for this behavior. The hide lists are handled by
47  // MaterialOutputAction in this case.
48  //
49  // Variables/AuxVariables also call the buildOutputHideVariableList method later, because when
50  // their actions are called the Output objects do not exist. This case is handled by the
51  // CheckOutputAction::checkVariableOutput.
52  if (build_list)
53  {
54  std::set<std::string> names_set;
55  names_set.insert(parameters.get<std::string>("_object_name"));
56  buildOutputHideVariableList(names_set);
57  }
58 }
59 
60 void
61 OutputInterface::buildOutputHideVariableList(std::set<std::string> variable_names)
62 {
63  // Set of available names
64  const std::set<OutputName> & avail = _oi_output_warehouse.getOutputNames();
65 
66  // Check for 'none'; hide variables on all outputs
67  if (_oi_outputs.find("none") != _oi_outputs.end())
68  for (const auto & name : avail)
70 
71  // Check for empty and 'all' in 'outputs' parameter; do not perform any variable restrictions in
72  // these cases
73  else if (_oi_outputs.empty() || _oi_outputs.find("all") != _oi_outputs.end())
74  return;
75 
76  // Limit the variable output to Output objects listed
77  else
78  {
79  // Create a list of outputs where the variable should be hidden
80  std::set<OutputName> hide;
81  std::set_difference(avail.begin(),
82  avail.end(),
83  _oi_outputs.begin(),
84  _oi_outputs.end(),
85  std::inserter(hide, hide.begin()));
86 
87  // If 'outputs' is specified add the object name to the list of items to hide
88  for (const auto & name : hide)
90  }
91 }
92 
93 const std::set<OutputName> &
95 {
96  return _oi_outputs;
97 }
std::string name(const ElemQuality q)
OutputWarehouse & _oi_output_warehouse
Reference to the OutputWarehouse for populating the Output object hide lists.
static InputParameters validParams()
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
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
Base class for MOOSE-based applications.
Definition: MooseApp.h:73
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
OutputInterface(const InputParameters &parameters, bool build_list=true)
Handles &#39;outputs&#39; parameter for objects that desire control of variable outputs.
InputParameters emptyInputParameters()
std::set< OutputName > _oi_outputs
The set of Output object names listed in the &#39;outputs&#39; parameter.
void buildOutputHideVariableList(std::set< std::string > variable_names)
Builds hide lists for output objects NOT listed in the &#39;outputs&#39; parameter.
void setReservedValues(const std::string &name, const std::set< std::string > &reserved)
Provide a set of reserved values for a parameter.
const std::set< OutputName > & getOutputNames()
Get a complete set of all output object names.
void addClassDescription(const std::string &doc_string)
This method adds a description of the class that will be displayed in the input file syntax dump...
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...
void addInterfaceHideVariables(const std::string &output_name, const std::set< std::string > &variable_names)
Insert variable names for hiding via the OutoutInterface.
const std::set< OutputName > & getOutputs()
Get the list of output objects that this class is restricted.
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...