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