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             : // Stocastic Tools Includes
      11             : #include "EvaluateSurrogate.h"
      12             : 
      13             : #include "Sampler.h"
      14             : 
      15             : registerMooseObject("StochasticToolsApp", EvaluateSurrogate);
      16             : 
      17             : InputParameters
      18        1534 : EvaluateSurrogate::validParams()
      19             : {
      20        1534 :   InputParameters params = StochasticReporter::validParams();
      21        1534 :   params += SurrogateModelInterface::validParams();
      22        1534 :   params += SamplerInterface::validParams();
      23        1534 :   params.addClassDescription("Tool for sampling surrogate models.");
      24        3068 :   params.addRequiredParam<std::vector<UserObjectName>>("model", "Name of surrogate models.");
      25        3068 :   params.addRequiredParam<SamplerName>("sampler",
      26             :                                        "Sampler to use for evaluating surrogate models.");
      27        3068 :   MultiMooseEnum rtypes(SurrogateModel::defaultResponseTypes().getRawNames(), "real");
      28        3068 :   params.addParam<MultiMooseEnum>(
      29             :       "response_type",
      30             :       rtypes,
      31             :       "The type of return value expected from the surrogate models, a single entry will use it for "
      32             :       "every model. Warning: not every model is able evaluate every response type.");
      33        1534 :   MultiMooseEnum estd("false=0 true=1", "false");
      34        3068 :   params.addParam<MultiMooseEnum>(
      35             :       "evaluate_std",
      36             :       estd,
      37             :       "Whether or not to evaluate standard deviation associated with each sample, a single entry "
      38             :       "will use it for every model. Warning: not every model can compute standard deviation.");
      39        1534 :   return params;
      40        1534 : }
      41             : 
      42         763 : EvaluateSurrogate::EvaluateSurrogate(const InputParameters & parameters)
      43             :   : StochasticReporter(parameters),
      44             :     SurrogateModelInterface(this),
      45         763 :     _sampler(getSampler("sampler")),
      46        3052 :     _response_types(getParam<MultiMooseEnum>("response_type"))
      47             : {
      48         763 :   const auto & model_names = getParam<std::vector<UserObjectName>>("model");
      49         763 :   _model.reserve(model_names.size());
      50        1645 :   for (const auto & nm : model_names)
      51         882 :     _model.push_back(&getSurrogateModelByName(nm));
      52             : 
      53         763 :   if (_response_types.size() != 1 && _response_types.size() != _model.size())
      54           0 :     paramError("response_type",
      55             :                "Number of entries must be 1 or equal to the number of entries in 'model'.");
      56             : 
      57         763 :   const auto & estd = getParam<MultiMooseEnum>("evaluate_std");
      58         763 :   if (estd.size() != 1 && estd.size() != _model.size())
      59           0 :     paramError("evaluate_std",
      60             :                "Nmber of entries must be 1 or equal to the number of entries in 'model'.");
      61         763 :   _doing_std.resize(_model.size());
      62        1645 :   for (const auto i : index_range(_model))
      63         882 :     _doing_std[i] = estd.size() == 1 ? estd[0] == "true" : estd[i] == "true";
      64             : 
      65         763 :   _real_values.resize(_model.size(), nullptr);
      66         763 :   _real_std.resize(_model.size(), nullptr);
      67         763 :   _vector_real_values.resize(_model.size(), nullptr);
      68         763 :   _vector_real_std.resize(_model.size(), nullptr);
      69        1645 :   for (const auto i : index_range(_model))
      70             :   {
      71         882 :     const std::string rtype = _response_types.size() == 1 ? _response_types[0] : _response_types[i];
      72         882 :     if (rtype == "real")
      73             :     {
      74         797 :       _real_values[i] = &declareStochasticReporter<Real>(model_names[i], _sampler);
      75         797 :       if (_doing_std[i])
      76         391 :         _real_std[i] = &declareStochasticReporter<Real>(model_names[i] + "_std", _sampler);
      77             :     }
      78          85 :     else if (rtype == "vector_real")
      79             :     {
      80          85 :       _vector_real_values[i] =
      81         170 :           &declareStochasticReporter<std::vector<Real>>(model_names[i], _sampler);
      82          85 :       if (_doing_std[i])
      83          51 :         _vector_real_std[i] =
      84         102 :             &declareStochasticReporter<std::vector<Real>>(model_names[i] + "_std", _sampler);
      85             :     }
      86             :     else
      87           0 :       paramError("response_type", "Unknown response type ", _response_types[i]);
      88             :   }
      89         763 : }
      90             : 
      91             : void
      92         763 : EvaluateSurrogate::execute()
      93             : {
      94             :   // Loop over samples
      95      163140 :   for (const auto ind : make_range(_sampler.getNumberOfLocalRows()))
      96             :   {
      97      162377 :     const std::vector<Real> data = _sampler.getNextLocalRow();
      98      325524 :     for (const auto m : index_range(_model))
      99             :     {
     100      163147 :       if (_real_values[m] && _real_std[m])
     101      124542 :         (*_real_values[m])[ind] = _model[m]->evaluate(data, (*_real_std[m])[ind]);
     102       38605 :       else if (_real_values[m])
     103       38220 :         (*_real_values[m])[ind] = _model[m]->evaluate(data);
     104         385 :       else if (_vector_real_values[m] && _vector_real_std[m])
     105         165 :         _model[m]->evaluate(data, (*_vector_real_values[m])[ind], (*_vector_real_std[m])[ind]);
     106         220 :       else if (_vector_real_values[m])
     107         220 :         _model[m]->evaluate(data, (*_vector_real_values[m])[ind]);
     108             :     }
     109      162377 :   }
     110         763 : }