ReporterData.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

#include "ReporterData.h"
#include "MooseApp.h"
#include "VariadicTable.h"

ReporterData::ReporterData(MooseApp & moose_app) : _app(moose_app) {}

void
ReporterData::copyValuesBack()
{
  for (const auto & name_context_pair : _context_ptrs)
    name_context_pair.second->copyValuesBack();
}

void
ReporterData::restoreState(bool verbose)
{
  // Table of reporter values that were and were not restored
  VariadicTable<std::string, std::string, std::string> summary_table({"Name", "Type", "Restored?"});

  for (const auto & [rname, context] : _context_ptrs)
  {
    const bool restored = context->restoreState();

    if (verbose)
      summary_table.addRow(
          rname.getCombinedName(), rname.specialTypeToName(), restored ? "YES" : "NO");
  }

  if (verbose && !_context_ptrs.empty())
  {
    std::stringstream oss;
    oss << "Reporter Restoration Summary:\n";
    summary_table.print(oss);
    mooseInfo(oss.str());
  }
}

void
ReporterData::finalize(const std::string & object_name)
{
  for (auto & name_context_pair : _context_ptrs)
    if (name_context_pair.first.getObjectName() == object_name)
      name_context_pair.second->finalize();
}

bool
ReporterData::hasReporterValue(const ReporterName & reporter_name) const
{
  return _context_ptrs.count(reporter_name);
}

std::set<ReporterName>
ReporterData::getReporterNames() const
{
  std::set<ReporterName> output;
  for (const auto & name_context_pair : _context_ptrs)
    output.insert(name_context_pair.second->name());
  return output;
}

std::set<std::string>
ReporterData::getPostprocessorNames() const
{
  std::set<std::string> output;
  for (const auto & name_context_pair : _context_ptrs)
    if (name_context_pair.first.isPostprocessor())
      output.insert(name_context_pair.first.getObjectName());
  return output;
}

DenseVector<Real>
ReporterData::getAllRealReporterValues() const
{
  DenseVector<Real> all_values;

  std::vector<Real> & output = all_values.get_values();

  for (const auto & name_context_pair : _context_ptrs)
  {
    const ReporterName & rname = name_context_pair.first;

    if (hasReporterValue<Real>(rname))
      output.push_back(getReporterValue<Real>(rname.getCombinedName()));

    if (hasReporterValue<std::vector<Real>>(rname))
    {
      const auto & vec = getReporterValue<std::vector<Real>>(rname.getCombinedName());
      for (const auto & v : vec)
        output.push_back(v);
    }
  }

  return all_values;
}

std::vector<std::string>
ReporterData::getAllRealReporterFullNames() const
{
  std::vector<std::string> output;

  for (const auto & name_context_pair : _context_ptrs)
  {
    const ReporterName & rname = name_context_pair.first;

    if (hasReporterValue<Real>(rname))
      output.push_back(rname.getCombinedName());

    if (hasReporterValue<std::vector<Real>>(rname))
    {
      auto pname = rname.getCombinedName();
      const auto & vec = getReporterValue<std::vector<Real>>(pname);
      for (unsigned int i = 0; i < vec.size(); ++i)
        output.push_back(pname + "/" + std::to_string(i));
    }
  }

  return output;
}

const ReporterContextBase &
ReporterData::getReporterContextBase(const ReporterName & reporter_name) const
{
  if (!hasReporterValue(reporter_name))
    mooseError("Unable to locate Reporter context with name: ", reporter_name);
  return *_context_ptrs.at(reporter_name);
}

ReporterContextBase &
ReporterData::getReporterContextBase(const ReporterName & reporter_name)
{
  if (!hasReporterValue(reporter_name))
    mooseError("Unable to locate Reporter context with name: ", reporter_name);
  return *_context_ptrs.at(reporter_name);
}

const ReporterStateBase &
ReporterData::getReporterStateBase(const ReporterName & reporter_name) const
{
  if (!hasReporterState(reporter_name))
    mooseError("Unable to locate Reporter state with name: ", reporter_name);
  return *_states.at(reporter_name);
}

ReporterStateBase &
ReporterData::getReporterStateBase(const ReporterName & reporter_name)
{
  if (!hasReporterState(reporter_name))
    mooseError("Unable to locate Reporter state with name: ", reporter_name);
  return *_states.at(reporter_name);
}

void
ReporterData::check() const
{
  std::string missing;
  for (const auto & name_state_pair : _states)
    if (!hasReporterValue(name_state_pair.first))
      missing += getReporterInfo(name_state_pair.first) + "\n";

  if (missing.size())
    mooseError("The following Reporter(s) were not declared:\n\n", missing);
}

RestartableDataValue &
ReporterData::getRestartableDataHelper(std::unique_ptr<RestartableDataValue> data_ptr,
                                       bool declare) const
{
  return _app.registerRestartableData(std::move(data_ptr), 0, !declare);
}

bool
ReporterData::hasReporterWithMode(const std::string & obj_name, const ReporterMode & mode) const
{
  for (const auto & name_context_pair : _context_ptrs)
    if (name_context_pair.first.getObjectName() == obj_name &&
        name_context_pair.second->getProducerModeEnum() == mode)
      return true;
  return false;
}

const ReporterProducerEnum &
ReporterData::getReporterMode(const ReporterName & reporter_name) const
{
  return getReporterContextBase(reporter_name).getProducerModeEnum();
}

bool
ReporterData::hasReporterState(const ReporterName & reporter_name) const
{
  return _states.count(reporter_name);
}

std::string
ReporterData::getReporterInfo(const ReporterStateBase & state, const ReporterContextBase * context)
{
  std::stringstream oss;

  const auto & name = state.getReporterName();

  if (name.isPostprocessor())
    oss << "Postprocessor \"" << name.getObjectName() << "\":\n";
  else
  {
    oss << name.specialTypeToName() << " \"" << name.getCombinedName() << "\":\n  Type:\n    "
        << state.valueType() << "\n";
  }
  oss << "  Producer:\n    ";
  if (context)
  {
    oss << context->getProducer().type() << " \"" << context->getProducer().name() << "\"";
    oss << "\n  Context type:\n    " << context->contextType();
  }
  else
    oss << "None";
  oss << "\n  Consumer(s):\n";
  if (state.getConsumers().empty())
    oss << "    None\n";
  else
    for (const auto & mode_object_pair : state.getConsumers())
    {
      const ReporterMode mode = mode_object_pair.first;
      const MooseObject * object = mode_object_pair.second;
      oss << "    " << object->typeAndName() << " (mode: " << mode << ")\n";
    }

  return oss.str();
}

std::string
ReporterData::getReporterInfo(const ReporterName & reporter_name) const
{
  return getReporterInfo(getReporterStateBase(reporter_name),
                         hasReporterValue(reporter_name) ? &getReporterContextBase(reporter_name)
                                                         : nullptr);
}

std::string
ReporterData::getReporterInfo() const
{
  std::string out = _states.empty() ? "No reporters were requested or declared." : "";
  for (const auto & name : getReporterNames())
    out += getReporterInfo(name) + "\n";
  return out;
}