ReporterData.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
 
#include "RestartableData.h"
#include "JsonIO.h"
#include "MooseUtils.h"
#include "ReporterState.h"
#include "ReporterContext.h"
#include "libmesh/parallel_object.h"
#include "libmesh/dense_vector.h"
#include <memory>
 
class MooseApp;
class Receiver;
 
class ReporterData
{
public:
  class WriteKey
  {
    WriteKey() {} // private constructor
    friend class Reporter;
    friend class Postprocessor;
    friend class Receiver;
    friend class ConstantPostprocessor;
    friend class VectorPostprocessor;
    friend class ReporterTransferInterface;
  };
 
  ReporterData(MooseApp & moose_app);
 
  template <typename T>
  bool hasReporterValue(const ReporterName & reporter_name) const;
 
  bool hasReporterValue(const ReporterName & reporter_name) const;
 
  template <typename T>
  bool hasReporterState(const ReporterName & reporter_name) const;
 
  bool hasReporterState(const ReporterName & reporter_name) const;
 
  std::set<ReporterName> getReporterNames() const;
 
  std::set<std::string> getPostprocessorNames() const;
 
  DenseVector<Real> getAllRealReporterValues() const;
 
  std::vector<std::string> getAllRealReporterFullNames() const;
 
  template <typename T>
  const T & getReporterValue(const ReporterName & reporter_name,
                             const MooseObject & consumer,
                             const ReporterMode & mode,
                             const std::size_t time_index = 0) const;
 
  template <typename T>
  const T & getReporterValue(const ReporterName & reporter_name,
                             const std::size_t time_index = 0) const;
 
  template <typename T>
  void setReporterValue(const ReporterName & reporter_name,
                        const T & value,
                        const std::size_t time_index = 0);
 
  template <typename T>
  void needReporterTimeIndex(const ReporterName & reporter_name, const std::size_t time_index);
 
 
  template <typename T, typename S, typename... Args>
  T & declareReporterValue(const ReporterName & reporter_name,
                           const ReporterMode & mode,
                           const MooseObject & producer,
                           Args &&... args);
 
  void finalize(const std::string & object_name);
 
  void copyValuesBack();
 
  void restoreState(bool verbose = false);
 
  void check() const;
 
  bool hasReporterWithMode(const std::string & obj_name, const ReporterMode & mode) const;
 
  const ReporterContextBase & getReporterContextBase(const ReporterName & reporter_name) const;
  ReporterContextBase & getReporterContextBase(const ReporterName & reporter_name);
 
  const ReporterStateBase & getReporterStateBase(const ReporterName & reporter_name) const;
  ReporterStateBase & getReporterStateBase(const ReporterName & reporter_name);
 
  const ReporterProducerEnum & getReporterMode(const ReporterName & reporter_name) const;
 
  static std::string getReporterInfo(const ReporterStateBase & state,
                                     const ReporterContextBase * context);
 
  std::string getReporterInfo(const ReporterName & reporter_name) const;
 
  std::string getReporterInfo() const;
 
private:
  MooseApp & _app;
 
  template <typename T>
  ReporterState<T> & getReporterStateHelper(const ReporterName & reporter_name,
                                            bool declare,
                                            const MooseObject * moose_object = nullptr) const;
 
  RestartableDataValue & getRestartableDataHelper(std::unique_ptr<RestartableDataValue> data_ptr,
                                                  bool declare) const;
 
  void restoreReporterStateIfAvailable(RestartableDataValue & state) const;
 
  mutable std::map<ReporterName, ReporterStateBase *> _states;
 
  std::map<ReporterName, std::unique_ptr<ReporterContextBase>> _context_ptrs;
};
 
template <typename T>
ReporterState<T> &
ReporterData::getReporterStateHelper(const ReporterName & reporter_name,
                                     bool declare,
                                     const MooseObject * moose_object /* = nullptr */) const
{
  if (hasReporterState(reporter_name))
  {
    const auto error_helper =
        [this, &reporter_name, &moose_object, &declare](const std::string & suffix)
    {
      std::stringstream oss;
      oss << "While " << (declare ? "declaring" : "requesting") << " a "
          << reporter_name.specialTypeToName() << " value with the name \""
          << reporter_name.getValueName() << "\"";
      if (!reporter_name.isPostprocessor() && !reporter_name.isVectorPostprocessor())
        oss << " and type \"" << MooseUtils::prettyCppType<T>() << "\"";
      oss << ",\na Reporter with the same name " << suffix << ".\n\n";
      oss << getReporterInfo(reporter_name);
 
      if (moose_object)
        moose_object->mooseError(oss.str());
      else
        mooseError(oss.str());
    };
 
    if (declare && hasReporterValue(reporter_name))
      error_helper("has already been declared");
    if (!hasReporterState<T>(reporter_name))
    {
      std::stringstream oss;
      oss << "has been " << (declare || !hasReporterValue(reporter_name) ? "requested" : "declared")
          << " with a different type";
      error_helper(oss.str());
    }
  }
 
  // Reporter states are stored as restartable data. The act of registering restartable data
  // may be done multiple times with the same name, which will happen when more than one
  // get value is done, or a get value and a declare is done. With this, we create a new
  // state every time, but said created state may not be the actual state if this state
  // is already registered as restartable data. Therefore, we create a state, and then
  // cast the restartable data received back to a state (which may be different than
  // the one we created, but that's okay)
  auto state_unique_ptr = std::make_unique<ReporterState<T>>(reporter_name);
  auto & restartable_value = getRestartableDataHelper(std::move(state_unique_ptr), declare);
 
  auto * state = dynamic_cast<ReporterState<T> *>(&restartable_value);
  mooseAssert(state, "Cast failed. The check above must be broken!");
 
  // See declareReporterValue for a comment on what happens if a state for the same
  // name is requested but with different special types. TLDR: ReporterNames with
  // different special types are not unique so they'll be the same entry
  _states.emplace(reporter_name, state);
 
  return *state;
}
 
template <typename T>
const T &
ReporterData::getReporterValue(const ReporterName & reporter_name,
                               const MooseObject & consumer,
                               const ReporterMode & mode,
                               const std::size_t time_index /* = 0 */) const
{
  auto & state = getReporterStateHelper<T>(reporter_name, /* declare = */ false, &consumer);
  state.addConsumer(mode, consumer);
  return state.value(time_index);
}
 
template <typename T, typename S, typename... Args>
T &
ReporterData::declareReporterValue(const ReporterName & reporter_name,
                                   const ReporterMode & mode,
                                   const MooseObject & producer,
                                   Args &&... args)
{
  // Get/create the ReporterState
  auto & state = getReporterStateHelper<T>(reporter_name, /* declare = */ true, &producer);
 
  // They key in _states (ReporterName) is not unique by special type. This is done on purpose
  // because we want to store reporter names a single name regardless of special type.
  // Because of this, we have the case where someone could request a reporter value
  // that is later declared as a pp or a vpp value. In this case, when it is first
  // requested, the _state entry will have a key and name with a special type of ANY.
  // When it's declared here (later), we will still find the correct entry because
  // we don't check the special type in the key/name. But... we want the actual
  // key and name to represent a pp or a vpp. Therefore, we'll set it properly,
  // remove the entry in the map (which has the ANY key), and re-add it so that it
  // has the pp/vpp key. This allows us to identify Reporters that really represent
  // pps/vpps in output and in error reporting.
  if (reporter_name.isPostprocessor() && !state.getReporterName().isPostprocessor())
  {
    state.setIsPostprocessor();
    _states.erase(reporter_name);
    _states.emplace(reporter_name, &state);
  }
  else if (reporter_name.isVectorPostprocessor() &&
           !state.getReporterName().isVectorPostprocessor())
  {
    state.setIsVectorPostprocessor();
    _states.erase(reporter_name);
    _states.emplace(reporter_name, &state);
  }
 
  mooseAssert(!_context_ptrs.count(reporter_name), "Context already exists");
 
  // Create the ReporterContext
  auto context_ptr = std::make_unique<S>(_app, producer, state, args...);
  context_ptr->init(mode); // initialize the mode, see ContextReporter
  _context_ptrs.emplace(reporter_name, std::move(context_ptr));
 
  // On recover, values declared after the bulk restore pass are skipped by it.
  // Restore this value in place from the still-open checkpoint reader (no-op on
  // normal runs and for values declared before the bulk restore runs, which are
  // handled by the bulk pass). This is done after context construction so that
  // context-driven resizes do not clobber the restore.
  restoreReporterStateIfAvailable(state);
 
  return state.value();
}
 
template <typename T>
bool
ReporterData::hasReporterValue(const ReporterName & reporter_name) const
{
  if (!hasReporterValue(reporter_name))
    return false;
  return dynamic_cast<const ReporterContext<T> *>(&getReporterContextBase(reporter_name));
}
 
template <typename T>
bool
ReporterData::hasReporterState(const ReporterName & reporter_name) const
{
  if (!hasReporterState(reporter_name))
    return false;
  return dynamic_cast<const ReporterState<T> *>(&getReporterStateBase(reporter_name));
}
 
template <typename T>
const T &
ReporterData::getReporterValue(const ReporterName & reporter_name,
                               const std::size_t time_index) const
{
  if (!hasReporterValue<T>(reporter_name))
    mooseError("Reporter name \"",
               reporter_name,
               "\" with type \"",
               MooseUtils::prettyCppType<T>(),
               "\" is not declared.");
 
  // Force the const version of value, which does not allow for increasing time index
  return static_cast<const ReporterState<T> &>(
             getReporterStateHelper<T>(reporter_name, /* declare = */ false))
      .value(time_index);
}
 
template <typename T>
void
ReporterData::setReporterValue(const ReporterName & reporter_name,
                               const T & value,
                               const std::size_t time_index)
{
  // https://stackoverflow.com/questions/123758/how-do-i-remove-code-duplication-between-similar-const-and-non-const-member-func
  const auto & me = *this;
  const_cast<T &>(me.getReporterValue<T>(reporter_name, time_index)) = value;
}
 
template <typename T>
void
ReporterData::needReporterTimeIndex(const ReporterName & reporter_name,
                                    const std::size_t time_index)
{
  getReporterValue<T>(reporter_name, 0); // for error checking that it is declared
  getReporterStateHelper<T>(reporter_name, /* declare = */ false).value(time_index);
}
 
// This is defined here to avoid cyclic includes, see ReporterContext.h
template <typename T>
void
ReporterContext<T>::transfer(ReporterData & r_data,
                             const ReporterName & r_name,
                             unsigned int time_index) const
{
  r_data.setReporterValue<T>(r_name, _state.value(), time_index);
}
 
// This is defined here to avoid cyclic includes, see ReporterContext.h
template <typename T>
void
ReporterContext<T>::transferToVector(ReporterData & r_data,
                                     const ReporterName & r_name,
                                     dof_id_type index,
                                     unsigned int time_index) const
{
  std::vector<T> & vec =
      const_cast<std::vector<T> &>(r_data.getReporterValue<std::vector<T>>(r_name, time_index));
 
  if (index >= vec.size())
    mooseError(
        "Requested index ", index, " is outside the bounds of the vector reporter value ", r_name);
  vec[index] = _state.value();
}
 
// This is defined here to avoid cyclic includes, see ReporterContext.h
template <typename T>
void
ReporterContext<T>::transferFromVector(ReporterData & r_data,
                                       const ReporterName & r_name,
                                       dof_id_type index,
                                       unsigned int time_index) const
{
  if constexpr (is_std_vector<T>::value)
  {
    if (index >= _state.value().size())
      mooseError("Requested index ",
                 index,
                 " is outside the bounds of the vector reporter value ",
                 r_name);
 
    using R = typename T::value_type;
    r_data.setReporterValue<R>(r_name, _state.value()[index], time_index);
  }
  else
  {
    libmesh_ignore(r_data);
    libmesh_ignore(r_name);
    libmesh_ignore(index);
    libmesh_ignore(time_index);
    mooseError("transferFromVector can only be used for reporter types that are specializatons of "
               "std::vector.");
  }
}
 
// This is defined here to avoid cyclic includes, see ReporterContext.h
template <typename T>
void
ReporterGeneralContext<T>::declareClone(ReporterData & r_data,
                                        const ReporterName & r_name,
                                        const ReporterMode & mode,
                                        const MooseObject & producer) const
{
  r_data.declareReporterValue<T, ReporterGeneralContext<T>>(r_name, mode, producer);
}
 
// This is defined here to avoid cyclic includes, see ReporterContext.h
template <typename T>
void
ReporterGeneralContext<T>::declareVectorClone(ReporterData & r_data,
                                              const ReporterName & r_name,
                                              const ReporterMode & mode,
                                              const MooseObject & producer) const
{
  r_data.declareReporterValue<std::vector<T>, ReporterVectorContext<T>>(r_name, mode, producer);
}
 
// This is defined here to avoid cyclic includes, see ReporterContext.h
template <typename T>
void
ReporterVectorContext<T>::declareClone(ReporterData &,
                                       const ReporterName &,
                                       const ReporterMode &,
                                       const MooseObject &) const
{
  mooseError("Cannot create clone with ReporterVectorContext.");
}
 
// This is defined here to avoid cyclic includes, see ReporterContext.h
template <typename T>
void
ReporterVectorContext<T>::declareVectorClone(ReporterData &,
                                             const ReporterName &,
                                             const ReporterMode &,
                                             const MooseObject &) const
{
  mooseError("Cannot create clone with ReporterVectorContext.");
}