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 "RestartableDataReporter.h"
      11             : 
      12             : #include "MooseUtils.h"
      13             : 
      14             : registerMooseObject("MooseApp", RestartableDataReporter);
      15             : 
      16             : InputParameters
      17       28678 : RestartableDataReporter::validParams()
      18             : {
      19       28678 :   InputParameters params = GeneralReporter::validParams();
      20       28678 :   params.addClassDescription("Reports restartable data and restartable meta data.");
      21             : 
      22       28678 :   MultiMooseEnum entries("value type declared loaded stored has_context", "value type");
      23       28678 :   params.addParam<MultiMooseEnum>(
      24             :       "entries", entries, "The entries to output for each restartable value");
      25             : 
      26       86034 :   params.addParam<bool>("allow_unimplemented",
      27       57356 :                         false,
      28             :                         "Set to true to allow the empty output of data that does not have a JSON "
      29             :                         "output implementation");
      30             : 
      31       28678 :   params.addParam<std::string>(
      32             :       "map", "", "The data map to use; if unset, use system restartable data");
      33             : 
      34       28678 :   params.addParam<std::vector<std::string>>(
      35             :       "include",
      36             :       {},
      37             :       "The data name patterns to include (* for matching all, ? for matching a single character)");
      38       28678 :   params.addParam<std::vector<std::string>>(
      39             :       "exclude",
      40             :       {},
      41             :       "The data name patterns to exclude (* for matching all, ? for matching a single character)");
      42             : 
      43       57356 :   return params;
      44       28678 : }
      45             : 
      46          74 : RestartableDataReporter::RestartableDataReporter(const InputParameters & parameters)
      47             :   : GeneralReporter(parameters),
      48          74 :     _data_params(getDataParams()),
      49          74 :     _allow_unimplemented(getParam<bool>("allow_unimplemented")),
      50          74 :     _include(getParam<std::vector<std::string>>("include")),
      51          74 :     _exclude(getParam<std::vector<std::string>>("exclude")),
      52          74 :     _values(declareValueByName<std::map<std::string, RestartableDataReporter::Value>>(
      53             :         "values",
      54         148 :         getParam<std::string>("map").size() ? REPORTER_MODE_ROOT : REPORTER_MODE_DISTRIBUTED)),
      55         148 :     _data_map(getParam<std::string>("map").size()
      56         124 :                   ? _app.getRestartableDataMap(getParam<std::string>("map"))
      57         124 :                   : _app.getRestartableData()[0])
      58             : {
      59          74 : }
      60             : 
      61             : RestartableDataValue::StoreJSONParams
      62          74 : RestartableDataReporter::getDataParams() const
      63             : {
      64          74 :   const auto & entries = getParam<MultiMooseEnum>("entries");
      65             : 
      66          74 :   RestartableDataValue::StoreJSONParams params;
      67          74 :   params.value = entries.isValueSet("value");
      68          74 :   params.type = entries.isValueSet("type");
      69          74 :   params.name = false;
      70          74 :   params.declared = entries.isValueSet("declared");
      71          74 :   params.loaded = entries.isValueSet("loaded");
      72          74 :   params.stored = entries.isValueSet("stored");
      73          74 :   params.has_context = entries.isValueSet("has_context");
      74             : 
      75          74 :   return params;
      76             : }
      77             : 
      78             : void
      79         123 : RestartableDataReporter::execute()
      80             : {
      81         123 :   _values.clear();
      82             : 
      83        4219 :   for (const auto & value : _data_map)
      84             :   {
      85             :     mooseAssert(!_values.count(value.name()), "Non-unique name");
      86             : 
      87             :     // Don't output JSON entries
      88        4100 :     if (typeid(nlohmann::json) == value.typeId())
      89        3660 :       continue;
      90             :     // Don't output Reporter data due to recursion
      91        4014 :     if (MooseUtils::globCompare(value.name(),
      92        8028 :                                 ReporterName::REPORTER_RESTARTABLE_DATA_PREFIX + "/*"))
      93          86 :       continue;
      94             :     // Does not match include patterns
      95       11168 :     if (_include.size() && std::find_if(_include.begin(),
      96             :                                         _include.end(),
      97        3620 :                                         [&value](const auto & pattern) {
      98        3620 :                                           return MooseUtils::globCompare(value.name(), pattern);
      99       11168 :                                         }) == _include.end())
     100        3466 :       continue;
     101             :     // Matches exclude patterns
     102         462 :     if (std::find_if(_exclude.begin(),
     103             :                      _exclude.end(),
     104          44 :                      [&value](const auto & pattern)
     105         968 :                      { return MooseUtils::globCompare(value.name(), pattern); }) != _exclude.end())
     106          22 :       continue;
     107             : 
     108         440 :     RestartableDataReporter::Value entry;
     109         440 :     entry.value = &value;
     110         440 :     entry.params = _data_params;
     111             : 
     112         440 :     if (!value.hasStoreJSON())
     113             :     {
     114          26 :       if (!_allow_unimplemented)
     115           4 :         mooseError("The method for outputting restartable data of type '",
     116           0 :                    value.type(),
     117             :                    "' is not implemented.\n\nTo omit data values that are not able to be "
     118             :                    "output, set Reporters/",
     119           4 :                    name(),
     120             :                    "/"
     121             :                    "allow_unimplemented=true,\nor skip the data with Reporters/",
     122           4 :                    name(),
     123             :                    "/[include/exclude].");
     124          22 :       entry.params.value = false;
     125             :     }
     126             : 
     127         436 :     _values.emplace(value.name(), entry);
     128             :   }
     129         119 : }
     130             : 
     131             : void
     132         352 : to_json(nlohmann::json & json, const RestartableDataReporter::Value & value)
     133             : {
     134             :   mooseAssert(value.value, "Not set");
     135         352 :   value.value->store(json, value.params);
     136         352 : }