https://mooseframework.inl.gov
CommonOutputAction.C
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://mooseframework.inl.gov
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 "CommonOutputAction.h"
12 #include "MooseApp.h"
13 #include "FEProblem.h"
14 #include "MooseObjectAction.h"
15 #include "ActionFactory.h"
16 #include "Output.h"
17 #include "OutputWarehouse.h"
18 #include "MooseUtils.h"
19 
20 // Extrnal includes
21 #include "tinydir.h"
22 #include "pcrecpp.h"
23 #include <libgen.h>
24 #include <sys/types.h>
25 #include <sys/stat.h>
26 #include <unistd.h>
27 
28 registerMooseAction("MooseApp", CommonOutputAction, "common_output");
29 registerMooseAction("MooseApp", CommonOutputAction, "add_output");
30 registerMooseAction("MooseApp", CommonOutputAction, "add_reporter");
31 
32 const ReporterName CommonOutputAction::perf_graph_json_reporter("perf_graph_json", "graph");
33 
36 {
38  params.addClassDescription("Adds short-cut syntax and common parameters to the Outputs block.");
39 
40  // Short-cut methods for typical output objects
41  params.addParam<bool>(
42  "exodus", false, "Output the results using the default settings for Exodus output.");
43  params.addParam<bool>(
44  "nemesis", false, "Output the results using the default settings for Nemesis output");
45  params.addParam<bool>(
46  "console", true, "Output the results using the default settings for Console output");
47  params.addParam<bool>("csv",
48  false,
49  "Output the scalar variable and postprocessors to a *.csv "
50  "file using the default CSV output.");
51  params.addParam<bool>("xml",
52  false,
53  "Output the vector postprocessors to a *.xml "
54  "file using the default XML output.");
55  params.addParam<bool>("json",
56  false,
57  "Output Reporter values to a *.json "
58  "file using the default JSON output.");
59  params.addParam<bool>(
60  "vtk", false, "Output the results using the default settings for VTKOutput output");
61  params.addParam<bool>(
62  "xda", false, "Output the results using the default settings for XDA/XDR output (ascii)");
63  params.addParam<bool>(
64  "xdr", false, "Output the results using the default settings for XDA/XDR output (binary)");
65  params.addParam<bool>(
66  "gmv", false, "Output the results using the default settings for GMV output");
67  params.addParam<bool>(
68  "tecplot", false, "Output the results using the default settings for Tecplot output");
69  params.addParam<bool>(
70  "gnuplot",
71  false,
72  "Output the scalar and postprocessor results using the default settings for GNUPlot output");
73  params.addParam<bool>(
74  "solution_history", false, "Print a solution history file (.slh) using the default settings");
75  params.addParam<bool>("progress", false, "Print a progress bar");
76  params.addParam<bool>("dofmap", false, "Create the dof map .json output file");
77  params.addParam<bool>("controls", false, "Enable the screen output of Control systems.");
78 
79  // Common parameters
80 
81  // Note: Be sure that objects that share these parameters utilize the same defaults
82  params.addParam<bool>("color", true, "Set to false to turn off all coloring in all outputs");
83  params.addParam<std::string>("file_base",
84  "Common file base name to be utilized with all output objects");
85  params.addParam<std::vector<std::string>>("output_if_base_contains",
86  "If this is supplied then output will only be done in "
87  "the case that the output base contains one of these "
88  "strings. This is helpful in outputting only a subset "
89  "of outputs when using MultiApps.");
90  params.addParam<unsigned int>(
91  "time_step_interval", 1, "The interval (number of time steps) at which output occurs");
92  params.addParam<unsigned int>("interval",
93  "The interval (number of time steps) at which output occurs");
94  params.deprecateParam("interval", "time_step_interval", "02/01/2025");
95  params.addParam<std::vector<Real>>("sync_times",
96  std::vector<Real>(),
97  "Times at which the output and solution is forced to occur");
98  params.addParam<Real>(
99  "minimum_time_interval", 0.0, "The minimum simulation time between output steps");
100  params.addParam<bool>(
101  "append_date", false, "When true the date and time are appended to the output filename.");
102  params.addParam<std::string>("append_date_format",
103  "The format of the date/time to append (see "
104  "http://www.cplusplus.com/reference/ctime/"
105  "strftime).");
106 
107  params.addParam<std::vector<VariableName>>(
108  "hide",
109  {},
110  "A list of the variables and postprocessors that should NOT be output to the Exodus "
111  "file (may include Variables, ScalarVariables, and Postprocessor names).");
112  params.addParam<std::vector<VariableName>>(
113  "show",
114  {},
115  "A list of the variables and postprocessors that should be output to the Exodus file "
116  "(may include Variables, ScalarVariables, and Postprocessor names).");
117 
118  // Add the 'execute_on' input parameter
120  exec_enum = {EXEC_INITIAL, EXEC_TIMESTEP_END};
121  params.addParam<ExecFlagEnum>("execute_on", exec_enum, exec_enum.getDocString());
122 
123  // Add special Console flags
124  params.addDeprecatedParam<bool>(
125  "print_perf_log", false, "Use perf_graph instead!", "Use perf_graph instead!");
126 
127  params.addParam<bool>(
128  "perf_graph", false, "Enable printing of the performance graph to the screen (Console)");
129 
130  params.addParam<bool>("perf_graph_live", true, "Enables printing of live progress messages");
131  params.addParam<Real>(
132  "perf_graph_live_time_limit", 5.0, "Time (in seconds) to wait before printing a message.");
133  params.addParam<unsigned int>(
134  "perf_graph_live_mem_limit", 100, "Memory (in MB) to cause a message to be printed.");
135  params.addParam<bool>("perf_graph_json", false, "Output the perf graph in JSON");
136  params.addParam<FileName>("perf_graph_json_file", "Path to a .json file to store the perf graph");
137 
138  params.addParam<bool>("print_mesh_changed_info",
139  false,
140  "When true, each time the mesh is changed the mesh information is printed");
141  params.addParam<bool>("print_linear_residuals",
142  true,
143  "Enable printing of linear residuals to the screen (Console)");
144  params.addParam<bool>("print_nonlinear_residuals",
145  true,
146  "Enable printing of nonlinear residuals to the screen (Console)");
147  params.addParam<bool>("print_nonlinear_converged_reason",
148  true,
149  "Enable/disable printing of the nonlinear solver convergence reason to the "
150  "screen. This parameter only affects the output of the third-party solver "
151  "(e.g. PETSc), not MOOSE itself.");
152  params.addParam<bool>("print_linear_converged_reason",
153  true,
154  "Enable/disable printing of the linear solver convergence reason to the "
155  "screen. This parameter only affects the output of the third-party solver "
156  "(e.g. PETSc), not MOOSE itself.");
157 
158  params.addParam<bool>(
159  "solution_invalidity_history",
160  true,
161  "Enable printing of the time history of the solution invalidity occurrences "
162  "to the screen (console)");
163 
164  // Return object
165  return params;
166 }
167 
169  : Action(params), _action_params(_action_factory.getValidParams("AddOutputAction"))
170 {
171 }
172 
173 void
175 {
176  if (_current_task == "common_output")
177  {
178  // Store the common output parameters in the OutputWarehouse
180 
181 // Create the actions for the short-cut methods
182 #ifdef LIBMESH_HAVE_EXODUS_API
183  if (getParam<bool>("exodus"))
184  create("Exodus", "exodus");
185 #else
186  if (getParam<bool>("exodus"))
187  mooseWarning("Exodus output requested but not enabled through libMesh");
188 #endif
189 
190 #ifdef LIBMESH_HAVE_NEMESIS_API
191  if (getParam<bool>("nemesis"))
192  create("Nemesis", "nemesis");
193 #else
194  if (getParam<bool>("nemesis"))
195  mooseWarning("Nemesis output requested but not enabled through libMesh");
196 #endif
197 
198  // Only create a Console if screen output was not created
199  if (getParam<bool>("console") && !hasConsole())
200  create("Console", "console");
201 
202  if (getParam<bool>("csv"))
203  create("CSV", "csv");
204 
205  if (getParam<bool>("xml"))
206  create("XMLOutput", "xml");
207 
208  if (getParam<bool>("json"))
209  create("JSON", "json");
210 
211 #ifdef LIBMESH_HAVE_VTK
212  if (getParam<bool>("vtk"))
213  create("VTK", "vtk");
214 #else
215  if (getParam<bool>("vtk"))
216  mooseWarning("VTK output requested but not enabled through libMesh");
217 #endif
218 
219  if (getParam<bool>("xda"))
220  create("XDA", "xda");
221 
222  if (getParam<bool>("xdr"))
223  create("XDR", "xdr");
224 
225  if (getParam<bool>("gmv"))
226  create("GMV", "gmv");
227 
228  if (getParam<bool>("tecplot"))
229  create("Tecplot", "tecplot");
230 
231  if (getParam<bool>("gnuplot"))
232  create("Gnuplot", "gnuplot");
233 
234  if (getParam<bool>("solution_history"))
235  create("SolutionHistory", "solution_history");
236 
237  if (getParam<bool>("progress"))
238  create("Progress", "progress");
239 
240  if (getParam<bool>("dofmap"))
241  create("DOFMap", "dofmap");
242 
243  // Helper for looking through a pair of [parameters, param name]
244  // to find a true boolean parameter, returning the pair that was found
245  const auto find_param =
246  [](const std::vector<std::pair<const InputParameters *, std::string>> & options)
247  {
248  std::optional<std::string> from_param_name;
249  const InputParameters * from_params = nullptr;
250  for (const auto & [params, param_name] : options)
251  if (params->template get<bool>(param_name))
252  {
253  from_param_name = param_name;
254  from_params = params;
255  break;
256  }
257  return std::make_pair(from_param_name, from_params);
258  };
259 
260  {
261  const auto [from_param_name, from_params] =
262  find_param({{&parameters(), "controls"}, {&_app.parameters(), "show_controls"}});
263  if (from_param_name)
264  create("ControlOutput", *from_param_name, from_params);
265  }
266 
267  if (!_app.getParam<bool>("no_timing"))
268  {
269  auto [from_param_name, from_params] = find_param({{&parameters(), "perf_graph"},
270  {&parameters(), "print_perf_log"},
271  {&_app.parameters(), "timing"}});
272  if (from_param_name)
273  create("PerfGraphOutput", *from_param_name, from_params);
274 
275  const auto add_perf_graph_json = [this](const std::string & from_param_name,
276  const std::string & set_param_name,
277  const std::string & set_param_value)
278  {
279  // To avoid this reporter value appearing in all other JSON output
281 
282  auto params = _factory.getValidParams("JSON");
283  params.set<std::vector<ReporterName>>("reporters") = {perf_graph_json_reporter};
284  params.set<ExecFlagEnum>("execute_on") = {EXEC_FINAL};
285  params.set<ExecFlagEnum>("execute_system_information_on") = {EXEC_NONE};
286  params.set<std::string>(set_param_name) = set_param_value;
287  params.set<bool>("distributed") = false;
288  if (set_param_name == "file_base")
289  params.set<bool>("append_date") = false;
290  create("JSON", from_param_name, &parameters(), &params, from_param_name);
291  };
292 
293  if (getParam<bool>("perf_graph_json"))
294  add_perf_graph_json("perf_graph_json", "file_base_suffix", "perf_graph");
295  if (isParamValid("perf_graph_json_file"))
296  {
297  const auto & file = getParam<FileName>("perf_graph_json_file");
298  if (MooseUtils::getExtension(file, true) != "json")
299  paramError("perf_graph_json_file", "File must end with .json");
300  const auto file_stripped = MooseUtils::stripExtension(file, true);
301  add_perf_graph_json("perf_graph_json_file", "file_base", file_stripped);
302  }
303 
304  if (!getParam<bool>("perf_graph_live"))
305  {
306  if (!from_param_name)
307  perfGraph().setActive(false);
309  }
310  }
311  else
312  {
313  perfGraph().setActive(false);
315  }
316 
317  perfGraph().setLiveTimeLimit(getParam<Real>("perf_graph_live_time_limit"));
318  perfGraph().setLiveMemoryLimit(getParam<unsigned int>("perf_graph_live_mem_limit"));
319 
320  if (getParam<bool>("solution_invalidity_history"))
321  {
322  create("SolutionInvalidityOutput", "solution_invalidity_history");
323  }
324 
325  if (!getParam<bool>("color"))
326  Moose::setColorConsole(false);
327  }
328  else if (_current_task == "add_output")
329  {
330  // More like remove output. This can't be done during the "common_output" task because the
331  // finite element problem is not yet constructed
332 
333  if (!getParam<bool>("console") || (isParamValid("print_nonlinear_converged_reason") &&
334  !getParam<bool>("print_nonlinear_converged_reason")))
336 
337  if (!getParam<bool>("console") || (isParamValid("print_linear_converged_reason") &&
338  !getParam<bool>("print_linear_converged_reason")))
340  }
341  else if (_current_task == "add_reporter")
342  {
343  if (!_app.getParam<bool>("no_timing") &&
344  (getParam<bool>("perf_graph_json") || isParamValid("perf_graph_json_file")))
345  {
346  auto params = _factory.getValidParams("PerfGraphReporter");
347  params.set<ExecFlagEnum>("execute_on") = EXEC_FINAL;
348  _problem->addReporter("PerfGraphReporter", perf_graph_json_reporter.getObjectName(), params);
349  }
350  }
351  else
352  mooseError("unrecognized task ", _current_task, " in CommonOutputAction.");
353 }
354 
355 void
356 CommonOutputAction::create(const std::string & object_type,
357  const std::optional<std::string> & param_name,
358  const InputParameters * const from_params /* = nullptr */,
359  const InputParameters * const apply_params /* = nullptr */,
360  const std::optional<std::string> & object_name /* = {} */)
361 {
362  // Create our copy of the parameters
363  auto params = _action_params;
364 
365  // Set the 'type =' parameters for the desired object
366  params.set<std::string>("type") = object_type;
367 
368  // Create the complete object name (uses lower case of type)
369  std::string name;
370  if (object_name)
371  name = *object_name;
372  else
373  {
374  name = object_type;
375  std::transform(name.begin(), name.end(), name.begin(), ::tolower);
376  }
377 
378  // Create the action
379  std::shared_ptr<MooseObjectAction> action = std::static_pointer_cast<MooseObjectAction>(
380  _action_factory.create("AddOutputAction", name, params));
381  auto & object_params = action->getObjectParams();
382 
383  // Set flag indicating that the object to be created was created with short-cut syntax
384  object_params.set<bool>("_built_by_moose") = true;
385 
386  // Apply any additional parameters
387  if (apply_params)
388  object_params.applyParameters(*apply_params);
389 
390  // Associate all action output object errors with param_name
391  // If from_params is specified, it means to associate it with parameters other than parameters()
392  if (param_name)
393  {
394  const InputParameters & associated_params = from_params ? *from_params : parameters();
395  associateWithParameter(associated_params, *param_name, object_params);
396  }
397 
398  // Add the action to the warehouse
399  _awh.addActionBlock(action);
400 }
401 
402 bool
404 {
405 
406  // Loop through all of the actions for adding output objects
407  for (ActionIterator it = _awh.actionBlocksWithActionBegin("add_output");
408  it != _awh.actionBlocksWithActionEnd("add_output");
409  it++)
410  {
411  MooseObjectAction * moa = dynamic_cast<MooseObjectAction *>(*it);
412  if (!moa)
413  continue;
414 
415  const std::string & type = moa->getMooseObjectType();
416  InputParameters & params = moa->getObjectParams();
417  if (type.compare("Console") == 0 && params.get<bool>("output_screen"))
418  return true;
419  }
420 
421  return false;
422 }
InputParameters _action_params
Parameters from the action being created (AddOutputAction)
A MultiMooseEnum object to hold "execute_on" flags.
Definition: ExecFlagEnum.h:21
void create(const std::string &object_type, const std::optional< std::string > &param_name, const InputParameters *const from_params=nullptr, const InputParameters *const apply_params=nullptr, const std::optional< std::string > &object_name={})
Helper method for creating the short-cut actions.
void addDeprecatedParam(const std::string &name, const T &value, const std::string &doc_string, const std::string &deprecation_message)
std::list< Action * >::iterator ActionIterator
alias to hide implementation details
ActionWarehouse & _awh
Reference to ActionWarehouse where we store object build by actions.
Definition: Action.h:159
bool hasConsole()
Check if a Console object that outputs to the screen has been defined.
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.
const ExecFlagType EXEC_NONE
Definition: Moose.C:27
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
InputParameters getValidParams(const std::string &name) const
Get valid parameters for the object.
Definition: Factory.C:68
static ExecFlagEnum getDefaultExecFlagEnum()
Return an ExecFlagEnum object with the available execution flags for Output objects.
Definition: Output.C:112
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
CommonOutputAction(const InputParameters &params)
void addActionBlock(std::shared_ptr< Action > blk)
This method add an Action instance to the warehouse.
const ExecFlagType EXEC_TIMESTEP_END
Definition: Moose.C:34
const InputParameters & parameters()
Get the parameters of the object.
Definition: MooseApp.h:161
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57
Base class for actions.
Definition: Action.h:33
void mooseWarning(Args &&... args) const
Emits a warning prefixed with object name and type.
std::shared_ptr< Action > create(const std::string &action, const std::string &action_name, InputParameters &parameters)
Definition: ActionFactory.C:39
static InputParameters validParams()
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
Factory & _factory
The Factory associated with the MooseApp.
std::string getExtension(const std::string &filename, const bool rfind=false)
Gets the extension of the passed file name.
Definition: MooseUtils.C:407
std::string stripExtension(const std::string &s, const bool rfind=false)
Removes any file extension from the given string s (i.e.
Definition: MooseUtils.C:423
static InputParameters validParams()
Definition: Action.C:24
InputParameters & getObjectParams()
Retrieve the parameters of the object to be created by this action.
std::vector< ReporterName > _common_reporter_names
The reporter names that we do not want to include in general JSON output.
void deprecateParam(const std::string &old_name, const std::string &new_name, const std::string &removal_date)
void setActive(bool active)
Turn on or off timing.
Definition: PerfGraph.h:129
void setLiveMemoryLimit(unsigned int mem_limit)
Sert the memory limit before a message prints.
Definition: PerfGraph.h:157
virtual void act() override
Method to add objects to the simulation or perform other setup tasks.
static const ReporterName perf_graph_json_reporter
void disableLivePrint()
Completely disables Live Print (cannot be restarted)
Definition: PerfGraph.C:67
const std::string & type() const
Get the type of this class.
Definition: MooseBase.h:51
const std::string & _current_task
The current action (even though we have separate instances for each action)
Definition: Action.h:162
std::string getDocString() const
Generate a documentation string for the "execute_on" parameter.
Definition: ExecFlagEnum.C:40
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:84
void paramError(const std::string &param, Args... args) const
Emits an error prefixed with the file and line number of the given param (from the input file) along ...
const std::string & getObjectName() const
Return the object name that produces the Reporter value.
Definition: ReporterName.C:35
ActionFactory & _action_factory
Builds Actions.
const std::string & getMooseObjectType() const
Return the object type to be created.
const T & getParam(const std::string &name)
Retrieve a parameter for the object.
Definition: MooseApp.h:1613
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
void dontAddNonlinearConvergedReason(FEProblemBase &fe_problem)
Function to ensure that -snes_converged_reason is not added to the PetscOptions storage object to be ...
registerMooseAction("MooseApp", CommonOutputAction, "common_output")
bool setColorConsole(bool use_color, bool force=false)
Turns color escape sequences on/off for info written to stdout.
Definition: Moose.C:754
PerfGraph & perfGraph()
Get the PerfGraph.
void associateWithParameter(const std::string &param_name, InputParameters &params) const
Associates the object&#39;s parameters params with the input location from this Action&#39;s parameter with t...
Definition: Action.C:158
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type.
const InputParameters & _pars
Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.
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 setCommonParameters(const InputParameters *params_ptr)
Stores the common InputParameters object.
std::shared_ptr< FEProblemBase > & _problem
Convenience reference to a problem this action works on.
Definition: Action.h:168
const InputParameters & parameters() const
Get the parameters of the object.
ActionIterator actionBlocksWithActionEnd(const std::string &task)
void addParam(const std::string &name, const S &value, const std::string &doc_string)
These methods add an optional parameter and a documentation string to the InputParameters object...
void dontAddLinearConvergedReason(FEProblemBase &fe_problem)
Function to ensure that -ksp_converged_reason is not added to the PetscOptions storage object to be l...
void setLiveTimeLimit(Real time_limit)
Set the time limit before a message prints.
Definition: PerfGraph.h:149
ActionIterator actionBlocksWithActionBegin(const std::string &task)
Iterators to the Actions in the warehouse.
const ExecFlagType EXEC_FINAL
Definition: Moose.C:44
The Reporter system is comprised of objects that can contain any number of data values.
Definition: ReporterName.h:30
Meta-action for creating common output object parameters This action serves two purpose, first it adds common output object parameters.
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:2414
const ExecFlagType EXEC_INITIAL
Definition: Moose.C:28