ParsedVectorVectorRealReductionReporter.C

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
 
#include "ParsedVectorVectorRealReductionReporter.h"
#include <cstddef>
 
registerMooseObject("MooseApp", ParsedVectorVectorRealReductionReporter);
 
InputParameters
ParsedVectorVectorRealReductionReporter::validParams()
{
  InputParameters params = ParsedReporterBase::validParams();
  params.addClassDescription("Use a parsed function to iterate through a rows of a vector of "
                             "vector and reduce it to a vector.");
  params.addRequiredParam<ReporterName>("vector_of_vector_reporter_name",
                                        "Reporter name with vector of vectors to reduce.");
 
  params.addRequiredParam<Real>("initial_reduction_value",
                                "Value to intialize the reduction with.");
 
  // vector_reporter_symbols are the two symbols for reduction value and current value for the
  // reduction operation, these symbols are enforced in the constructor with a mooseError
  params.set<std::vector<std::string>>("vector_reporter_symbols") = {"reduction_value",
                                                                     "indexed_value"};
  params.suppressParameter<std::vector<std::string>>("vector_reporter_symbols");
  params.suppressParameter<std::vector<std::string>>("scalar_reporter_symbols");
 
  return params;
}
 
ParsedVectorVectorRealReductionReporter::ParsedVectorVectorRealReductionReporter(
    const InputParameters & parameters)
  : ParsedReporterBase(parameters),
    _initial_reduction_value(getParam<Real>("initial_reduction_value")),
    _vec_of_vec_name(getParam<ReporterName>("vector_of_vector_reporter_name")),
    _output_reporter(
        declareValueByName<std::vector<Real>>(getParam<std::string>("name"), REPORTER_MODE_ROOT)),
    _reporter_data(getReporterValueByName<std::vector<std::vector<Real>>>(
        getParam<ReporterName>("vector_of_vector_reporter_name")))
{
  // parse function
  std::string function = getParam<std::string>("expression");
  // make sure the expression has the two required variables, vi and vplus
  if (function.find("reduction_value") == std::string::npos ||
      function.find("indexed_value") == std::string::npos)
    paramError(
        "expression",
        "Parsed function must contain the two symbols 'reduction_value' and 'indexed_value'.");
}
 
void
ParsedVectorVectorRealReductionReporter::finalize()
{
  std::size_t ncols = _reporter_data.size();
  std::size_t nrows = 0;
  if (!_reporter_data.empty())
    nrows = _reporter_data[0].size();
 
  for (auto & reporter_vector : _reporter_data)
  {
    if (reporter_vector.size() != nrows)
      mooseError("Every vector in 'vector_of_vector_reporter_name=",
                 _vec_of_vec_name,
                 "' must be the same size.",
                 "\nFirst Vector size = ",
                 nrows,
                 "\nCurrent Vector size = ",
                 reporter_vector.size());
  }
 
  _output_reporter.clear();
  _output_reporter.resize(nrows, _initial_reduction_value);
  for (const auto i_row : make_range(nrows))
  {
    Real reduction = _initial_reduction_value;
    for (const auto j_col : make_range(ncols))
    {
      _func_params[0] = reduction;
      _func_params[1] = _reporter_data[j_col][i_row];
 
      if (_use_t)
        _func_params[2] = _t;
 
      reduction = evaluate(_func_F);
    }
    _output_reporter[i_row] = reduction;
  }
}