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;
  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;
}