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);
}