OutputWarehouse.C

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
 
// MOOSE includes
#include "OutputWarehouse.h"
#include "Output.h"
#include "Console.h"
#include "FileOutput.h"
#include "Checkpoint.h"
#include "FEProblem.h"
#include "TableOutput.h"
#include "Exodus.h"
 
#include <libgen.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
 
OutputWarehouse::OutputWarehouse(MooseApp & app)
  : PerfGraphInterface(app, "OutputWarehouse"),
    _app(app),
    _buffer_action_console_outputs(false),
    _common_params_ptr(NULL),
    _output_exec_flag(EXEC_CUSTOM),
    _force_output(false),
    _last_message_ended_in_newline(true),
    _last_buffer(NULL),
    _num_printed(0)
{
  // Set the reserved names
  _reserved.insert("none"); // allows 'none' to be used as a keyword in 'outputs' parameter
  _reserved.insert("all");  // allows 'all' to be used as a keyword in 'outputs' parameter
}
 
OutputWarehouse::~OutputWarehouse()
{
  // If the output buffer is not empty, it needs to be written
  if (_console_buffer.str().length())
    mooseConsole();
}
 
void
OutputWarehouse::initialSetup()
{
  TIME_SECTION("initialSetup", 5, "Setting Up Outputs");
 
  resetFileBase();
 
  for (const auto & obj : _all_objects)
    obj->initialSetup();
}
 
void
OutputWarehouse::timestepSetup()
{
  for (const auto & obj : _all_objects)
    obj->timestepSetup();
}
 
void
OutputWarehouse::customSetup(const ExecFlagType & exec_type)
{
  for (const auto & obj : _all_objects)
    obj->customSetup(exec_type);
}
 
void
OutputWarehouse::solveSetup()
{
  for (const auto & obj : _all_objects)
    obj->solveSetup();
}
 
void
OutputWarehouse::jacobianSetup()
{
  for (const auto & obj : _all_objects)
    obj->jacobianSetup();
}
 
void
OutputWarehouse::residualSetup()
{
  for (const auto & obj : _all_objects)
    obj->residualSetup();
}
 
void
OutputWarehouse::subdomainSetup()
{
  for (const auto & obj : _all_objects)
    obj->subdomainSetup();
}
 
void
OutputWarehouse::addOutput(std::shared_ptr<Output> const output)
{
  _all_ptrs.push_back(output);
 
  // Add the object to the warehouse storage, Checkpoint placed at end so they are called last
  Checkpoint * cp = dynamic_cast<Checkpoint *>(output.get());
  if (cp != NULL)
    _all_objects.push_back(output.get());
  else
    _all_objects.insert(_all_objects.begin(), output.get());
 
  // Store the name and pointer
  _object_map[output->name()] = output.get();
  _object_names.insert(output->name());
 
  // Insert object sync times to the global set
  const std::set<Real> & sync_times = output->getSyncTimes();
  _sync_times.insert(sync_times.begin(), sync_times.end());
}
 
bool
OutputWarehouse::hasOutput(const std::string & name) const
{
  return _object_map.find(name) != _object_map.end();
}
 
bool
OutputWarehouse::hasMaterialPropertyOutput(const std::string & name) const
{
  const auto found_object = hasOutput(name);
  if (!found_object)
    return false;
  else
  {
    // Check if output object supports material property output
    const auto * output_object = cast_ptr<const Output *>(_object_map.at(name));
    return output_object->supportsMaterialPropertyOutput();
  }
}
 
const std::set<OutputName> &
OutputWarehouse::getOutputNames()
{
  if (_object_names.empty() && _app.actionWarehouse().hasActions("add_output"))
  {
    const auto & actions = _app.actionWarehouse().getActionListByName("add_output");
    for (const auto & act : actions)
      _object_names.insert(act->name());
  }
  return _object_names;
}
 
void
OutputWarehouse::addOutputFilename(const OutputName & obj_name, const OutFileBase & filename)
{
  _file_base_map[obj_name].insert(filename);
  for (const auto & it : _file_base_map)
    if (it.first != obj_name && it.second.find(filename) != it.second.end())
      mooseError("An output file with the name, ",
                 filename,
                 ", already exists. If both outputs fall back to a common 'file_base' set in the "
                 "[Outputs] block, give one of them its own distinct 'file_base' or set "
                 "'append_object_name = true' on it to avoid this collision.");
}
 
void
OutputWarehouse::outputStep(ExecFlagType type)
{
  if (_force_output)
    type = EXEC_FORCED;
 
  for (const auto & obj : _all_objects)
    if (obj->enabled())
      obj->outputStep(type);
 
  flushConsoleBuffer();
 
  // Reset force output flag
  _force_output = false;
}
 
void
OutputWarehouse::meshChanged()
{
  for (const auto & obj : _all_objects)
    obj->meshChanged();
}
 
static std::mutex moose_console_mutex;
 
void
OutputWarehouse::mooseConsole()
{
  mooseConsole(_console_buffer);
}
 
void
OutputWarehouse::mooseConsole(std::ostringstream & buffer)
{
  std::lock_guard<std::mutex> lock(moose_console_mutex);
 
  const auto clear_buffer = [&buffer]()
  {
    buffer.clear();
    buffer.str("");
  };
 
  const auto objects = getOutputs<Console>();
  const auto & awh = _app.actionWarehouse();
  const bool has_add_output = awh.hasTask("add_output");
  const bool add_output_done = has_add_output && awh.isTaskComplete("add_output");
 
  if (objects.empty() && add_output_done)
  {
    // No Console exists and none can be added anymore (e.g. console = false): drop the
    // message, otherwise the buffer grows without bound and every flush copies it.
    // No need to build the message string or track newline state.
    clear_buffer();
  }
  else
  {
    std::string message = buffer.str();
 
    // If someone else is writing - then we may need a newline
    if (&buffer != _last_buffer && !_last_message_ended_in_newline)
      message = '\n' + message;
 
    if (!objects.empty())
    {
      // Pass the current output buffer to all Console Output objects
      for (const auto & obj : objects)
        obj->mooseConsole(message);
      clear_buffer();
    }
    else if (has_add_output && !_buffer_action_console_outputs)
    {
      // Messages to console before its construction are immediately flushed and cleared.
      // Only indent the first line if the last message ended in a newline.
      const bool ends_in_newline = message.empty() || message.back() == '\n';
      if (_app.multiAppLevel() > 0)
        MooseUtils::indentMessage(_app.name(), message, COLOR_CYAN, _last_message_ended_in_newline);
 
      Moose::out << message << std::flush;
      clear_buffer();
      _last_message_ended_in_newline = ends_in_newline;
    }
  }
 
  _last_buffer = &buffer;
 
  _num_printed++;
}
 
void
OutputWarehouse::flushConsoleBuffer()
{
  if (!_console_buffer.str().empty())
    mooseConsole();
}
 
void
OutputWarehouse::setFileNumbers(std::map<std::string, unsigned int> input, unsigned int offset)
{
  for (const auto & obj : _all_objects)
  {
    FileOutput * ptr = dynamic_cast<FileOutput *>(obj);
    if (ptr != NULL)
    {
      std::map<std::string, unsigned int>::const_iterator it = input.find(ptr->name());
      if (it != input.end())
      {
        int value = it->second + offset;
        if (value < 0)
          ptr->setFileNumber(0);
        else
          ptr->setFileNumber(it->second + offset);
      }
    }
  }
}
 
std::map<std::string, unsigned int>
OutputWarehouse::getFileNumbers()
{
 
  std::map<std::string, unsigned int> output;
  for (const auto & obj : _all_objects)
  {
    FileOutput * ptr = dynamic_cast<FileOutput *>(obj);
    if (ptr != NULL)
      output[ptr->name()] = ptr->getFileNumber();
  }
  return output;
}
 
void
OutputWarehouse::setCommonParameters(const InputParameters * params_ptr)
{
  _common_params_ptr = params_ptr;
}
 
const InputParameters *
OutputWarehouse::getCommonParameters() const
{
  return _common_params_ptr;
}
 
bool
OutputWarehouse::commonFileBaseSet() const
{
  return _common_params_ptr && _common_params_ptr->isParamValid("file_base");
}
 
std::set<Real> &
OutputWarehouse::getSyncTimes()
{
  return _sync_times;
}
 
void
OutputWarehouse::addInterfaceHideVariables(const std::string & output_name,
                                           const std::set<std::string> & variable_names)
{
  _interface_map[output_name].insert(variable_names.begin(), variable_names.end());
}
 
void
OutputWarehouse::buildInterfaceHideVariables(const std::string & output_name,
                                             std::set<std::string> & hide)
{
  std::map<std::string, std::set<std::string>>::const_iterator it =
      _interface_map.find(output_name);
  if (it != _interface_map.end())
    hide = it->second;
}
 
void
OutputWarehouse::checkOutputs(const std::set<OutputName> & names,
                              const bool supports_material_output)
{
  std::string reserved_name = "";
  for (const auto & name : names)
  {
    const bool is_reserved_name = isReservedName(name);
    if (is_reserved_name)
      reserved_name = name;
    if (!is_reserved_name)
    {
      if (!hasOutput(name))
        mooseError("The output object '", name, "' is not a defined output object.");
      if (supports_material_output && !hasMaterialPropertyOutput(name))
        mooseError("The output object '", name, "' does not support material output.");
    }
  }
  if (!reserved_name.empty() && names.size() > 1)
    mooseError("When setting output name to reserved name '" + reserved_name +
               "', only one entry is allowed in outputs parameter.");
}
 
std::set<OutputName>
OutputWarehouse::getAllMaterialPropertyOutputNames() const
{
  std::set<OutputName> output_names;
  for (const auto & pair : _object_map)
  {
    const auto * output = cast_ptr<const Output *>(pair.second);
    if (output->supportsMaterialPropertyOutput())
      output_names.insert(pair.first);
  }
  return output_names;
}
 
const std::set<std::string> &
OutputWarehouse::getReservedNames() const
{
  return _reserved;
}
 
bool
OutputWarehouse::isReservedName(const std::string & name)
{
  return _reserved.find(name) != _reserved.end();
}
 
void
OutputWarehouse::setOutputExecutionType(ExecFlagType type)
{
  _output_exec_flag = type;
}
 
void
OutputWarehouse::allowOutput(bool state)
{
  for (const auto & obj : _all_objects)
    obj->allowOutput(state);
}
 
void
OutputWarehouse::forceOutput()
{
  _force_output = true;
}
 
void
OutputWarehouse::reset()
{
  for (const auto & pair : _object_map)
  {
    auto * table = dynamic_cast<TableOutput *>(pair.second);
    if (table != NULL)
      table->clear();
    auto * exodus = dynamic_cast<Exodus *>(pair.second);
    if (exodus != NULL)
      exodus->clear();
  }
}
 
void
OutputWarehouse::resetFileBase()
{
  // Tentatively resolve every FileOutput that will fall back to the app's
  // file_base -- shortcut-syntax outputs built by CommonOutputAction and
  // sub-block outputs alike, as long as neither sets its own 'file_base' --
  // and tally the results by the resulting (extension-inclusive) filename.
  // Two fallback outputs whose tentative filenames match this way would
  // otherwise collide (see #4215); shortcut outputs are included here so a
  // sub-block output colliding with a shortcut output is detected too, even
  // though only sub-block outputs act on the collision below (shortcut
  // outputs always keep the common file_base verbatim).
  std::map<std::string, unsigned int> fallback_filename_counts;
  for (const auto & obj : _all_objects)
    if (FileOutput * file_output = dynamic_cast<FileOutput *>(obj))
      if (!obj->getParam<bool>("_file_base_set_by_own_block"))
      {
        file_output->setFileBase(_app.getOutputFileBase());
        fallback_filename_counts[file_output->filename()]++;
      }
 
  // Set the file base from the application to FileOutputs and add associated filenames
  for (const auto & obj : _all_objects)
    if (FileOutput * file_output = dynamic_cast<FileOutput *>(obj))
    {
      std::string file_base;
      if (obj->parameters().get<bool>("_built_by_moose"))
      {
        // Shortcut-syntax outputs always keep the common/default file_base
        // verbatim; the object name is never appended to them.
        if (obj->isParamValid("file_base"))
          file_base = obj->getParam<std::string>("file_base");
        else
          file_base = _app.getOutputFileBase();
      }
      else
      {
        // A sub-block output that doesn't set its own 'file_base' and whose
        // tentatively-resolved filename collides with another output's --
        // another sub-block, or a shortcut-syntax output -- must be
        // disambiguated. MOOSE will not silently choose a name for the user
        // in that case: require the user to explicitly opt in to appending
        // the object name (or to explicitly opt out and accept the
        // collision) rather than doing it for them. With no common
        // 'file_base' set at all, the object name is always appended,
        // matching the ordinary default naming scheme -- there is no
        // collision to speak of in that case.
        const bool collides = commonFileBaseSet() &&
                              !obj->getParam<bool>("_file_base_set_by_own_block") &&
                              fallback_filename_counts[file_output->filename()] > 1;
 
        if (collides && !obj->parameters().isParamSetByUser("append_object_name"))
          mooseError(
              "The output object '",
              obj->name(),
              "' would write to the file '",
              file_output->filename(),
              "', which is also used by another output object, because both fall back to the "
              "common 'file_base' set in the [Outputs] block. MOOSE will not silently rename an "
              "output to resolve this collision. Set 'append_object_name = true' on '",
              obj->name(),
              "' (or on the other colliding output(s)) to have the object name appended and "
              "disambiguate the filenames, or give '",
              obj->name(),
              "' its own distinct 'file_base'.");
 
        const bool append_by_default = !commonFileBaseSet();
        const bool append = obj->parameters().isParamSetByUser("append_object_name")
                                ? obj->getParam<bool>("append_object_name")
                                : append_by_default;
 
        if (append)
          file_base = _app.getOutputFileBase(true) + "_" + obj->name();
        else
          file_base = _app.getOutputFileBase();
      }
 
      file_output->setFileBase(file_base);
      addOutputFilename(obj->name(), file_output->filename());
    }
}