ActiveLearningReporterBase.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 "StochasticReporter.h"
 
template <typename T>
class ActiveLearningReporterTempl;
 
template <typename T>
class ActiveLearningReporterTempl : public StochasticReporter
{
public:
  static InputParameters validParams();
 
  ActiveLearningReporterTempl(const InputParameters & parameters);
 
  virtual void execute() override;
 
protected:
  virtual ReporterName declareStochasticReporterClone(const Sampler & sampler,
                                                      const ReporterData & from_data,
                                                      const ReporterName & from_reporter,
                                                      std::string prefix = "") override;
 
  const Sampler & sampler() const { return _sampler; }
 
  const std::vector<std::vector<Real>> & getGlobalInputData() const
  {
    _input_data_requested = true;
    return _input_data;
  }
 
  const std::vector<T> & getGlobalOutputData() const
  {
    _output_data_requested = true;
    return _output_data;
  }
 
  virtual void preNeedSample() {}
 
  virtual bool needSample(const std::vector<Real> & /*row*/,
                          dof_id_type /*local_ind*/,
                          dof_id_type /*global_ind*/,
                          T & /*val*/)
  {
    return true;
  }
 
  Sampler & _sampler;
 
private:
  std::vector<bool> & _need_sample;
  std::vector<T> * _data = nullptr;
 
  mutable bool _input_data_requested = false;
  mutable bool _output_data_requested = false;
  std::vector<std::vector<Real>> _input_data;
  std::vector<T> _output_data;
};
 
template <typename T>
InputParameters
ActiveLearningReporterTempl<T>::validParams()
{
  InputParameters params = StochasticReporter::validParams();
  params.addRequiredParam<SamplerName>("sampler", "The sampler used to produce data.");
  return params;
}
 
template <typename T>
ActiveLearningReporterTempl<T>::ActiveLearningReporterTempl(const InputParameters & parameters)
  : StochasticReporter(parameters),
    _sampler(this->template getSampler<Sampler>("sampler")),
    _need_sample(this->template declareStochasticReporter<bool>("need_sample", _sampler))
{
}
 
template <typename T>
void
ActiveLearningReporterTempl<T>::execute()
{
  // If requesting global data, fill it in
  if (_input_data_requested)
  {
    // Gather inputs for the current step
    _input_data.resize(_sampler.getNumberOfRows());
    for (const auto i : make_range(_sampler.getNumberOfRows()))
      _input_data[i] = _sampler.getSampleRow(i);
  }
  if (_output_data_requested)
  {
    if (!_data)
      mooseError("Output data has been requested, but none was declared in this object.");
    _output_data = *_data;
    _communicator.allgather(_output_data);
  }
 
  // Optional call for before sampler loop
  preNeedSample();
 
  // Dummy value in case _data has not been declared yet
  T dummy;
  // Loop over samples to determine if sample is needed. Replace value in _data
  // (typically only if a sample is not needed). We insert a dummy value in case
  // _data has not been declared.
  for (dof_id_type i = 0, global_i = _sampler.getLocalRowBegin();
       i < _sampler.getNumberOfLocalRows();
       ++i, ++global_i)
    _need_sample[i] =
        needSample(_sampler.getSampleRow(global_i), i, global_i, (_data ? (*_data)[i] : dummy));
}
 
template <typename T>
ReporterName
ActiveLearningReporterTempl<T>::declareStochasticReporterClone(const Sampler & sampler,
                                                               const ReporterData & from_data,
                                                               const ReporterName & from_reporter,
                                                               std::string prefix)
{
  // Only one value is allowed to be declared
  if (_data)
    this->mooseError(type(), " can only declare a single reporter value.");
  // Make sure the inputted sampler is the same one in the parameters
  else if (sampler.name() != _sampler.name())
    this->paramError("sampler",
                     "Inputted sampler, ",
                     _sampler.name(),
                     ", is not the same as the one producing data, ",
                     sampler.name(),
                     ".");
  // Make sure reporter value exists
  else if (!from_data.hasReporterValue(from_reporter))
    this->mooseError("Reporter value ", from_reporter, " has not been declared.");
  // Make sure the reporter value is the right type
  else if (!from_data.hasReporterValue<T>(from_reporter))
    this->mooseError(
        type(), " can only use reporter values of type ", MooseUtils::prettyCppType<T>(), ".");
 
  std::string value_name = (prefix.empty() ? "" : prefix + ":") + from_reporter.getObjectName() +
                           ":" + from_reporter.getValueName();
  _data = &this->declareStochasticReporter<T>(value_name, sampler);
  return {name(), value_name};
}