ReporterInterface.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 "MooseTypes.h"
#include "ReporterData.h"
#include "MooseObject.h"

// Forward declarations
class FEProblemBase;
class InputParameters;

class ReporterInterface
{
public:
  static InputParameters validParams();
  ReporterInterface(const MooseObject * moose_object);

#ifdef MOOSE_KOKKOS_ENABLED

  ReporterInterface(const ReporterInterface & object, const Moose::Kokkos::FunctorCopy & key);
#endif

protected:

  template <typename T>
  const T & getReporterValue(const std::string & param_name, const std::size_t time_index = 0);
  template <typename T>
  const T & getReporterValue(const std::string & param_name,
                             ReporterMode mode,
                             const std::size_t time_index = 0);
  // doco-normal-methods-end


  template <typename T>
  const T & getReporterValueByName(const ReporterName & reporter_name,
                                   const std::size_t time_index = 0);
  template <typename T>
  const T & getReporterValueByName(const ReporterName & reporter_name,
                                   ReporterMode mode,
                                   const std::size_t time_index = 0);


  bool hasReporterValue(const std::string & param_name) const;
  bool hasReporterValueByName(const ReporterName & reporter_name) const;
  template <typename T>
  bool hasReporterValue(const std::string & param_name) const;
  template <typename T>
  bool hasReporterValueByName(const ReporterName & reporter_name) const;


  const ReporterContextBase &
  getReporterContextBaseByName(const ReporterName & reporter_name) const;

  const ReporterName & getReporterName(const std::string & param_name) const;

  virtual void addReporterDependencyHelper(const ReporterName & /*state_name*/) {}

private:
  bool reportersAdded() const;

  template <typename T>
  void possiblyCheckHasReporter(const ReporterName & reporter_name,
                                const std::string & param_name = "") const;

  const InputParameters & _ri_params;

  FEProblemBase & _ri_fe_problem_base;

  const ReporterData & _ri_reporter_data;

  const MooseObject & _ri_moose_object;
};

template <typename T>
const T &
ReporterInterface::getReporterValue(const std::string & param_name, const std::size_t time_index)
{
  return getReporterValue<T>(param_name, REPORTER_MODE_UNSET, time_index);
}

template <typename T>
const T &
ReporterInterface::getReporterValue(const std::string & param_name,
                                    ReporterMode mode,
                                    const std::size_t time_index)
{
  const auto & reporter_name = getReporterName(param_name);

  possiblyCheckHasReporter<T>(reporter_name, param_name);

  return getReporterValueByName<T>(reporter_name, mode, time_index);
}

template <typename T>
const T &
ReporterInterface::getReporterValueByName(const ReporterName & reporter_name,
                                          const std::size_t time_index)
{
  return getReporterValueByName<T>(reporter_name, REPORTER_MODE_UNSET, time_index);
}

template <typename T>
const T &
ReporterInterface::getReporterValueByName(const ReporterName & reporter_name,
                                          ReporterMode mode,
                                          const std::size_t time_index)
{
  possiblyCheckHasReporter<T>(reporter_name);

  addReporterDependencyHelper(reporter_name);

  return _ri_reporter_data.getReporterValue<T>(reporter_name, _ri_moose_object, mode, time_index);
}

template <typename T>
bool
ReporterInterface::hasReporterValue(const std::string & param_name) const
{
  if (!reportersAdded())
    _ri_moose_object.mooseError(
        "Cannot call hasReporterValue() until all Reporters have been constructed.");

  return hasReporterValueByName<T>(getReporterName(param_name));
}

template <typename T>
bool
ReporterInterface::hasReporterValueByName(const ReporterName & reporter_name) const
{
  if (!reportersAdded())
    _ri_moose_object.mooseError(
        "Cannot call hasReporterValueByName() until all Reporters have been constructed.");

  return _ri_reporter_data.hasReporterValue<T>(reporter_name);
}

template <typename T>
void
ReporterInterface::possiblyCheckHasReporter(const ReporterName & reporter_name,
                                            const std::string & param_name /* = "" */) const
{
  if (reportersAdded() && !hasReporterValueByName<T>(reporter_name))
  {
    std::stringstream oss;
    oss << "A Reporter value with the name \"" << reporter_name << "\" and type \""
        << MooseUtils::prettyCppType<T>() << "\" was not found.";

    if (_ri_params.isParamValid(param_name))
      _ri_moose_object.paramError(param_name, oss.str());
    else
      _ri_moose_object.mooseError(oss.str());
  }
}