OutputWarehouse.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
// MOOSE includes
#include "Output.h"
 
// Forward declarations
class FEProblemBase;
class InputParameters;
 
class OutputWarehouse
{
public:
  OutputWarehouse(MooseApp & app);
 
  /*
   * Class destructor
   * The OutputWarehouse deletes all output objects passed in via addOutput
   */
  virtual ~OutputWarehouse();
 
  void addOutput(std::shared_ptr<Output> & output);
 
  const std::set<OutputName> & getOutputNames();
 
  bool hasOutput(const std::string & name) const;
 
  void meshChanged();
 
  void buildInterfaceHideVariables(const std::string & output_name, std::set<std::string> & hide);
 
  void setFileNumbers(std::map<std::string, unsigned int> input, unsigned int offset = 0);
 
  std::map<std::string, unsigned int> getFileNumbers();
 
  void setCommonParameters(InputParameters * params_ptr);
 
  InputParameters * getCommonParameters();
 
  std::set<Real> & getSyncTimes();
 
  void checkOutputs(const std::set<OutputName> & names);
 
  template <typename T>
  T * getOutput(const OutputName & name);
 
  template <typename T>
  std::vector<T *> getOutputs(const std::vector<OutputName> & names);
 
  template <typename T>
  std::vector<T *> getOutputs() const;
 
  template <typename T>
  std::vector<OutputName> getOutputNames();
 
  const std::set<std::string> & getReservedNames() const;
 
  bool isReservedName(const std::string & name);
 
  void mooseConsole();
 
  std::ostringstream & consoleBuffer() { return _console_buffer; }
 
  void bufferConsoleOutputsBeforeConstruction(bool buffer)
  {
    _buffer_action_console_outputs = buffer;
  }
 
  void setLoggingRequested() { _logging_requested = true; }
 
  bool getLoggingRequested() const { return _logging_requested; }
 
  void reset();
 
private:
  void outputStep(ExecFlagType type);
 
 
  void allowOutput(bool state);
  template <typename T>
  void allowOutput(bool state);
 
  void forceOutput();
 
  std::vector<std::shared_ptr<Output>> _all_ptrs;
 
  void addOutputFilename(const OutFileBase & filename);
 
  void initialSetup();
 
  void timestepSetup();
 
  void solveSetup();
 
  void jacobianSetup();
 
  void residualSetup();
 
  void subdomainSetup();
 
  void addInterfaceHideVariables(const std::string & output_name,
                                 const std::set<std::string> & variable_names);
 
  void setOutputExecutionType(ExecFlagType type);
 
  void flushConsoleBuffer();
 
  MooseApp & _app;
 
  std::vector<Output *> _all_objects;
 
  bool _buffer_action_console_outputs;
 
  std::map<OutputName, Output *> _object_map;
 
  std::set<OutputName> _object_names;
 
  std::set<OutFileBase> _file_base_set;
 
  InputParameters * _common_params_ptr;
 
  std::set<Real> _sync_times;
 
  std::string _input_file_name;
 
  std::map<OutputName, std::set<AuxVariableName>> _material_output_map;
 
  std::set<AuxVariableName> _all_material_output_variables;
 
  std::set<std::string> _reserved;
 
  std::ostringstream _console_buffer;
 
  std::map<std::string, std::set<std::string>> _interface_map;
 
  ExecFlagType _output_exec_flag;
 
  bool _force_output;
 
  bool _logging_requested;
 
  bool _last_message_ended_in_newline;
 
  // Allow complete access:
  // FEProblemBase for calling initial, timestepSetup, outputStep, etc. methods
  friend class FEProblemBase;
 
  // MaterialOutputAction for calling addInterfaceHideVariables
  friend class MaterialOutputAction;
 
  // OutputInterface for calling addInterfaceHideVariables
  friend class OutputInterface;
 
  // Console for calling flushConsoleBuffer()
  friend class PetscOutput;
};
 
template <typename T>
T *
OutputWarehouse::getOutput(const OutputName & name)
{
  // Check that the object exists
  if (!hasOutput(name))
    mooseError("An output object with the name '", name, "' does not exist.");
 
  // Attempt to cast the object to the correct type
  T * output = dynamic_cast<T *>(_object_map[name]);
 
  // Error if the cast fails
  if (output == NULL)
    mooseError("An output object with the name '", name, "' for the specified type does not exist");
 
  // Return the object
  return output;
}
 
template <typename T>
std::vector<T *>
OutputWarehouse::getOutputs(const std::vector<OutputName> & names)
{
  // The vector to output
  std::vector<T *> outputs;
 
  // Populate the vector
  for (std::vector<OutputName>::const_iterator it = names.begin(); it != names.end(); ++it)
    outputs.push_back(getOutput<T>(*it));
 
  // Return the objects
  return outputs;
}
 
template <typename T>
std::vector<T *>
OutputWarehouse::getOutputs() const
{
  // The vector to output
  std::vector<T *> outputs;
 
  // Populate the vector
  for (std::map<OutputName, Output *>::const_iterator it = _object_map.begin();
       it != _object_map.end();
       ++it)
  {
    T * output = dynamic_cast<T *>(it->second);
    if (output != NULL)
      outputs.push_back(output);
  }
 
  // Return the objects
  return outputs;
}
 
template <typename T>
std::vector<OutputName>
OutputWarehouse::getOutputNames()
{
  // The output vector
  std::vector<OutputName> names;
 
  // Loop through the objects and store the name if the type cast succeeds
  for (std::map<OutputName, Output *>::const_iterator it = _object_map.begin();
       it != _object_map.end();
       ++it)
  {
    T * output = dynamic_cast<T *>(it->second);
    if (output != NULL)
      names.push_back(it->first);
  }
 
  // Return the names
  return names;
}
 
template <typename T>
void
OutputWarehouse::allowOutput(bool state)
{
  std::vector<T *> outputs = getOutputs<T>();
  for (typename std::vector<T *>::iterator it = outputs.begin(); it != outputs.end(); ++it)
    (*it)->allowOutput(state);
}