Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #include "ParsedReporterBase.h"
      11             : 
      12             : InputParameters
      13       59572 : ParsedReporterBase::validParams()
      14             : {
      15       59572 :   InputParameters params = GeneralReporter::validParams();
      16       59572 :   params += FunctionParserUtils<false>::validParams();
      17      357432 :   params.addRequiredCustomTypeParam<std::string>(
      18             :       "expression", "FunctionExpression", "function expression");
      19      238288 :   params.addParam<std::string>("name", "result", "Name of output reporter.");
      20      238288 :   params.addParam<std::vector<std::string>>(
      21             :       "vector_reporter_symbols", {}, "Expression symbol for each reporter");
      22      238288 :   params.addParam<std::vector<std::string>>(
      23             :       "scalar_reporter_symbols",
      24             :       {},
      25             :       "Expression symbol for each scalar reporter, i.e. postprocessors");
      26      238288 :   params.addParam<std::vector<std::string>>(
      27             :       "constant_names",
      28             :       {},
      29             :       "Vector of constants used in the parsed function (use this for kB etc.)");
      30      238288 :   params.addParam<std::vector<ReporterName>>("scalar_reporter_names",
      31             :                                              "Scalar reporter names to apply function to.");
      32      238288 :   params.addParam<std::vector<std::string>>(
      33             :       "constant_expressions",
      34             :       {},
      35             :       "Vector of values for the constants in constant_names (can be an FParser expression)");
      36      119144 :   params.addParam<bool>(
      37      119144 :       "use_t", false, "Make time (t) variables available in the function expression.");
      38       59572 :   return params;
      39           0 : }
      40             : 
      41         276 : ParsedReporterBase::ParsedReporterBase(const InputParameters & parameters)
      42             :   : GeneralReporter(parameters),
      43             :     FunctionParserUtils(parameters),
      44         276 :     _use_t(getParam<bool>("use_t")),
      45         552 :     _vector_reporter_symbols(getParam<std::vector<std::string>>("vector_reporter_symbols")),
      46        1104 :     _scalar_reporter_symbols(getParam<std::vector<std::string>>("scalar_reporter_symbols"))
      47             : {
      48             :   // checking that symbols and names vectors are the same size
      49         552 :   if (parameters.isParamValid("scalar_reporter_names"))
      50             :   {
      51             :     // get scalar reporter can be checked and gotten here if input
      52             :     // Vector reporters must be handled differently by each derived class
      53             :     const std::vector<ReporterName> scalar_reporter_names(
      54         152 :         getParam<std::vector<ReporterName>>("scalar_reporter_names"));
      55             : 
      56          76 :     if (scalar_reporter_names.size() != _scalar_reporter_symbols.size())
      57           8 :       paramError("scalar_reporter_names",
      58             :                  "scalar_reporter_names and scalar_reporter_symbols must be the same size:  Number "
      59             :                  "of scalar_reporter_names=",
      60             :                  scalar_reporter_names.size(),
      61             :                  ";  Number of scalar_reporter_symbols=",
      62             :                  _scalar_reporter_symbols.size());
      63          72 :     _scalar_reporter_data.resize(scalar_reporter_names.size());
      64         212 :     for (const auto rep_index : index_range(_scalar_reporter_data))
      65         280 :       _scalar_reporter_data[rep_index] =
      66         140 :           &getReporterValueByName<Real>(scalar_reporter_names[rep_index], REPORTER_MODE_ROOT);
      67          72 :   }
      68             : 
      69             :   // build reporters argument; order in derived classes must use this order
      70             :   // first add vector reporter symbols
      71         272 :   std::string symbol_str;
      72         786 :   for (const auto i : index_range(_vector_reporter_symbols))
      73         514 :     symbol_str += (symbol_str.empty() ? "" : ",") + _vector_reporter_symbols[i];
      74             :   // next add scalar reporter symbols
      75         412 :   for (const auto i : index_range(_scalar_reporter_symbols))
      76         140 :     symbol_str += (symbol_str.empty() ? "" : ",") + _scalar_reporter_symbols[i];
      77             : 
      78             :   // add time if required
      79         272 :   if (_use_t)
      80          26 :     symbol_str += (symbol_str.empty() ? "" : ",") + std::string("t");
      81             : 
      82             :   // Create parsed function
      83         272 :   _func_F = std::make_shared<SymFunction>();
      84        1088 :   parsedFunctionSetup(_func_F,
      85         816 :                       getParam<std::string>("expression"),
      86             :                       symbol_str,
      87             :                       getParam<std::vector<std::string>>("constant_names"),
      88             :                       getParam<std::vector<std::string>>("constant_expressions"),
      89             :                       comm());
      90             : 
      91             :   // reserve storage for parameter passing buffer
      92         272 :   _func_params.resize(_vector_reporter_symbols.size() + _scalar_reporter_symbols.size() + _use_t);
      93         272 : }