StatisticsReporter.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 "GeneralReporter.h"
#include "VectorCalculators.h"
 
#include "nlohmann/json.h"
 
template <typename InType, typename OutType>
class ReporterStatisticsContext
  : public ReporterGeneralContext<std::pair<OutType, std::vector<OutType>>>
{
public:
  ReporterStatisticsContext(const libMesh::ParallelObject & other,
                            const MooseObject & producer,
                            ReporterState<std::pair<OutType, std::vector<OutType>>> & state,
                            const InType & data,
                            const ReporterProducerEnum & mode,
                            const MooseEnumItem & stat);
 
  ReporterStatisticsContext(const libMesh::ParallelObject & other,
                            const MooseObject & producer,
                            ReporterState<std::pair<OutType, std::vector<OutType>>> & state,
                            const InType & data,
                            const ReporterProducerEnum & mode,
                            const MooseEnumItem & stat,
                            const MooseEnum & ci_method,
                            const std::vector<Real> & ci_levels,
                            unsigned int ci_replicates,
                            unsigned int ci_seed);
 
  virtual void finalize() override;
  virtual void storeInfo(nlohmann::json & json) const override;
 
private:
  const InType & _data;
 
  const ReporterProducerEnum & _data_mode;
 
  std::unique_ptr<StochasticTools::Calculator<InType, OutType>> _calc_ptr;
 
  std::unique_ptr<StochasticTools::BootstrapCalculator<InType, OutType>> _ci_calc_ptr = nullptr;
};
 
template <typename InType, typename OutType>
ReporterStatisticsContext<InType, OutType>::ReporterStatisticsContext(
    const libMesh::ParallelObject & other,
    const MooseObject & producer,
    ReporterState<std::pair<OutType, std::vector<OutType>>> & state,
    const InType & data,
    const ReporterProducerEnum & mode,
    const MooseEnumItem & stat)
  : ReporterGeneralContext<std::pair<OutType, std::vector<OutType>>>(other, producer, state),
    _data(data),
    _data_mode(mode),
    _calc_ptr(StochasticTools::makeCalculator<InType, OutType>(stat, other))
{
}
 
template <typename InType, typename OutType>
ReporterStatisticsContext<InType, OutType>::ReporterStatisticsContext(
    const libMesh::ParallelObject & other,
    const MooseObject & producer,
    ReporterState<std::pair<OutType, std::vector<OutType>>> & state,
    const InType & data,
    const ReporterProducerEnum & mode,
    const MooseEnumItem & stat,
    const MooseEnum & ci_method,
    const std::vector<Real> & ci_levels,
    unsigned int ci_replicates,
    unsigned int ci_seed)
  : ReporterStatisticsContext<InType, OutType>(other, producer, state, data, mode, stat)
{
  _ci_calc_ptr = StochasticTools::makeBootstrapCalculator<InType, OutType>(
      ci_method, other, ci_levels, ci_replicates, ci_seed, *_calc_ptr);
}
 
template <typename InType, typename OutType>
void
ReporterStatisticsContext<InType, OutType>::finalize()
{
  if (_data_mode == REPORTER_MODE_DISTRIBUTED || this->processor_id() == 0)
  {
    this->_state.value().first = _calc_ptr->compute(_data, _data_mode == REPORTER_MODE_DISTRIBUTED);
 
    if (_ci_calc_ptr)
      this->_state.value().second =
          _ci_calc_ptr->compute(_data, _data_mode == REPORTER_MODE_DISTRIBUTED);
  }
 
  ReporterGeneralContext<std::pair<OutType, std::vector<OutType>>>::finalize();
}
 
template <typename InType, typename OutType>
void
ReporterStatisticsContext<InType, OutType>::storeInfo(nlohmann::json & json) const
{
  ReporterGeneralContext<std::pair<OutType, std::vector<OutType>>>::storeInfo(json);
  json["stat"] = _calc_ptr->name();
}
 
class StatisticsReporter : public GeneralReporter
{
public:
  static InputParameters validParams();
  StatisticsReporter(const InputParameters & parameters);
 
  virtual void initialize() final;
 
  virtual void execute() final {};
  virtual void finalize() final {};
  virtual void store(nlohmann::json & json) const override;
 
private:
  // Statistics to be computed
  const MultiMooseEnum & _compute_stats;
 
  // CI Method to be computed (optional)
  const MooseEnum & _ci_method;
 
  // CI levels to be computed
  const std::vector<Real> & _ci_levels;
 
  // Number of CI replicates to use in Bootstrap methods
  const unsigned int & _ci_replicates;
 
  // Random seed for producing CI replicates
  const unsigned int & _ci_seed;
 
  bool _initialized;
 
  template <typename InType, typename OutType>
  void declareValueHelper(const ReporterName & r_name);
};