Reporter.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 "MooseTypes.h"
#include "OutputInterface.h"
#include "ReporterData.h"
#include "InputParameters.h"
 
// System includes
#include <type_traits>
 
// Forward declarations
class FEProblemBase;
 
class Reporter : public OutputInterface
{
public:
  static InputParameters validParams();
  Reporter(const MooseObject * moose_object);
  virtual ~Reporter() = default;
 
#ifdef MOOSE_KOKKOS_ENABLED
  Reporter(const Reporter & object, const Moose::Kokkos::FunctorCopy & key);
#endif
 
  virtual void store(nlohmann::json & json) const;
 
  virtual bool shouldStore() const { return true; }
 
  virtual void declareLateValues() {}
 
protected:
 
  template <typename T, template <typename> class S = ReporterGeneralContext, typename... Args>
  T & declareValue(const std::string & param_name, Args &&... args);
  template <typename T, template <typename> class S = ReporterGeneralContext, typename... Args>
  T & declareValue(const std::string & param_name, ReporterMode mode, Args &&... args);
  template <typename T, template <typename> class S = ReporterGeneralContext, typename... Args>
  T & declareValueByName(const ReporterValueName & value_name, Args &&... args);
  template <typename T, template <typename> class S = ReporterGeneralContext, typename... Args>
  T & declareValueByName(const ReporterValueName & value_name, ReporterMode mode, Args &&... args);
 
  template <typename T, typename S, typename... Args>
  T & declareValue(const std::string & param_name, Args &&... args);
  template <typename T, typename S, typename... Args>
  T & declareValue(const std::string & param_name, ReporterMode mode, Args &&... args);
  template <typename T, typename S, typename... Args>
  T & declareValueByName(const ReporterValueName & value_name, Args &&... args);
  template <typename T, typename S, typename... Args>
  T & declareValueByName(const ReporterValueName & value_name, ReporterMode mode, Args &&... args);
 
  template <typename T, typename... Args>
  T & declareUnusedValue(Args &&... args);
 
private:
  struct UnusedWrapperBase
  {
    virtual ~UnusedWrapperBase() {}
  };
 
  template <typename T>
  struct UnusedWrapper : UnusedWrapperBase
  {
    T value;
  };
 
  const ReporterValueName & getReporterValueName(const std::string & param_name) const;
 
  const MooseObject & _reporter_moose_object;
 
  const InputParameters & _reporter_params;
 
  const std::string & _reporter_name;
 
  FEProblemBase & _reporter_fe_problem;
 
  ReporterData & _reporter_data;
 
  std::vector<std::unique_ptr<UnusedWrapperBase>> _unused_values;
};
 
template <typename T, template <typename> class S, typename... Args>
T &
Reporter::declareValue(const std::string & param_name, Args &&... args)
{
  return declareValue<T, S<T>>(param_name, REPORTER_MODE_UNSET, args...);
}
 
template <typename T, template <typename> class S, typename... Args>
T &
Reporter::declareValue(const std::string & param_name, ReporterMode mode, Args &&... args)
{
  return declareValue<T, S<T>>(param_name, mode, args...);
}
 
template <typename T, typename S, typename... Args>
T &
Reporter::declareValue(const std::string & param_name, Args &&... args)
{
  return declareValue<T, S>(param_name, REPORTER_MODE_UNSET, args...);
}
 
template <typename T, typename S, typename... Args>
T &
Reporter::declareValue(const std::string & param_name, ReporterMode mode, Args &&... args)
{
  return declareValueByName<T, S>(getReporterValueName(param_name), mode, args...);
}
 
template <typename T, template <typename> class S, typename... Args>
T &
Reporter::declareValueByName(const ReporterValueName & value_name, Args &&... args)
{
  return declareValueByName<T, S<T>>(value_name, REPORTER_MODE_UNSET, args...);
}
 
template <typename T, template <typename> class S, typename... Args>
T &
Reporter::declareValueByName(const ReporterValueName & value_name,
                             ReporterMode mode,
                             Args &&... args)
{
  return declareValueByName<T, S<T>>(value_name, mode, args...);
}
 
template <typename T, typename S, typename... Args>
T &
Reporter::declareValueByName(const ReporterValueName & value_name, Args &&... args)
{
  return declareValueByName<T, S>(value_name, REPORTER_MODE_UNSET, args...);
}
 
template <typename T, typename S, typename... Args>
T &
Reporter::declareValueByName(const ReporterValueName & value_name,
                             ReporterMode mode,
                             Args &&... args)
{
  const ReporterName state_name(_reporter_name, value_name);
 
  buildOutputHideVariableList({state_name.getCombinedName()});
 
  // Only thread 0 will declare the reporter value. The rest will get a reference
  // to an UnusedValue
  const THREAD_ID tid = _reporter_moose_object.parameters().isParamValid("_tid")
                            ? _reporter_moose_object.parameters().get<THREAD_ID>("_tid")
                            : 0;
  if (tid)
    return declareUnusedValue<T>();
  return _reporter_data.declareReporterValue<T, S>(
      state_name, mode, _reporter_moose_object, args...);
}
 
template <typename T, typename... Args>
T &
Reporter::declareUnusedValue(Args &&... args)
{
  _unused_values.emplace_back(std::make_unique<UnusedWrapper<T>>(std::forward(args)...));
  UnusedWrapper<T> * wrapper = dynamic_cast<UnusedWrapper<T> *>(_unused_values.back().get());
  return wrapper->value;
}