OutputWarehouse.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* 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"
#include "PerfGraphInterface.h"
 
// System includes
#include <atomic>
 
// Forward declarations
class FEProblemBase;
class InputParameters;
 
class OutputWarehouse : protected PerfGraphInterface
{
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;
 
  bool hasMaterialPropertyOutput(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(const InputParameters * params_ptr);
 
  const InputParameters * getCommonParameters() const;
 
  std::set<Real> & getSyncTimes();
 
  void checkOutputs(const std::set<OutputName> & names,
                    const bool supports_material_output = false);
 
  std::set<OutputName> getAllMaterialPropertyOutputNames() const;
 
  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();
 
  void mooseConsole(std::ostringstream & buffer);
 
  std::ostringstream & consoleBuffer() { return _console_buffer; }
 
  void bufferConsoleOutputsBeforeConstruction(bool buffer)
  {
    _buffer_action_console_outputs = buffer;
  }
 
  void reset();
 
  void solveSetup();
 
  unsigned long long int numPrinted() const { return _num_printed; }
 
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 OutputName & obj_name, const OutFileBase & filename);
 
  void initialSetup();
 
  void timestepSetup();
 
  void customSetup(const ExecFlagType & exec_type);
 
  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();
 
  void resetFileBase();
 
  MooseApp & _app;
 
  std::vector<Output *> _all_objects;
 
  bool _buffer_action_console_outputs;
 
  std::map<OutputName, Output *> _object_map;
 
  std::set<OutputName> _object_names;
 
  std::map<OutputName, std::set<OutFileBase>> _file_base_map;
 
  const 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 _last_message_ended_in_newline;
 
  const std::ostringstream * _last_buffer;
 
  std::atomic<unsigned long long int> _num_printed;
 
  // 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 PetscOutputInterface;
 
  // MooseApp for resetFileBase()
  friend class MooseApp;
};
 
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);
}