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       28690 : RestartableDataReporter::validParams()
      18             : {
      19       28690 :   InputParameters params = GeneralReporter::validParams();
      20       28690 :   params.addClassDescription("Reports restartable data and restartable meta data.");
      21             : 
      22       28690 :   MultiMooseEnum entries("value type declared loaded stored has_context", "value type");
      23       28690 :   params.addParam<MultiMooseEnum>(
      24             :       "entries", entries, "The entries to output for each restartable value");
      25             : 
      26       86070 :   params.addParam<bool>("allow_unimplemented",
      27       57380 :                         false,
      28             :                         "Set to true to allow the empty output of data that does not have a JSON "
      29             :                         "output implementation");
      30             : 
      31       28690 :   params.addParam<std::string>(
      32             :       "map", "", "The data map to use; if unset, use system restartable data");
      33             : 
      34       28690 :   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       28690 :   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       57380 :   return params;
      44       28690 : }
      45             : 
      46          80 : RestartableDataReporter::RestartableDataReporter(const InputParameters & parameters)
      47             :   : GeneralReporter(parameters),
      48          80 :     _data_params(getDataParams()),
      49          80 :     _allow_unimplemented(getParam<bool>("allow_unimplemented")),
      50          80 :     _include(getParam<std::vector<std::string>>("include")),
      51          80 :     _exclude(getParam<std::vector<std::string>>("exclude")),
      52          80 :     _values(declareValueByName<std::map<std::string, RestartableDataReporter::Value>>(
      53             :         "values",
      54         160 :         getParam<std::string>("map").size() ? REPORTER_MODE_ROOT : REPORTER_MODE_DISTRIBUTED)),
      55         160 :     _data_map(getParam<std::string>("map").size()
      56         134 :                   ? _app.getRestartableDataMap(getParam<std::string>("map"))
      57         134 :                   : _app.getRestartableData()[0])
      58             : {
      59          80 : }
      60             : 
      61             : RestartableDataValue::StoreJSONParams
      62          80 : RestartableDataReporter::getDataParams() const
      63             : {
      64          80 :   const auto & entries = getParam<MultiMooseEnum>("entries");
      65             : 
      66          80 :   RestartableDataValue::StoreJSONParams params;
      67          80 :   params.value = entries.isValueSet("value");
      68          80 :   params.type = entries.isValueSet("type");
      69          80 :   params.name = false;
      70          80 :   params.declared = entries.isValueSet("declared");
      71          80 :   params.loaded = entries.isValueSet("loaded");
      72          80 :   params.stored = entries.isValueSet("stored");
      73          80 :   params.has_context = entries.isValueSet("has_context");
      74             : 
      75          80 :   return params;
      76             : }
      77             : 
      78             : void
      79         134 : RestartableDataReporter::execute()
      80             : {
      81         134 :   _values.clear();
      82             : 
      83        4704 :   for (const auto & value : _data_map)
      84             :   {
      85             :     mooseAssert(!_values.count(value.name()), "Non-unique name");
      86             : 
      87             :     // Don't output JSON entries
      88        4574 :     if (typeid(nlohmann::json) == value.typeId())
      89        4094 :       continue;
      90             :     // Don't output Reporter data due to recursion
      91        4480 :     if (MooseUtils::globCompare(value.name(),
      92        8960 :                                 ReporterName::REPORTER_RESTARTABLE_DATA_PREFIX + "/*"))
      93          94 :       continue;
      94             :     // Does not match include patterns
      95       12486 :     if (_include.size() && std::find_if(_include.begin(),
      96             :                                         _include.end(),
      97        4050 :                                         [&value](const auto & pattern) {
      98        4050 :                                           return MooseUtils::globCompare(value.name(), pattern);
      99       12486 :                                         }) == _include.end())
     100        3882 :       continue;
     101             :     // Matches exclude patterns
     102         504 :     if (std::find_if(_exclude.begin(),
     103             :                      _exclude.end(),
     104          48 :                      [&value](const auto & pattern)
     105        1056 :                      { return MooseUtils::globCompare(value.name(), pattern); }) != _exclude.end())
     106          24 :       continue;
     107             : 
     108         480 :     RestartableDataReporter::Value entry;
     109         480 :     entry.value = &value;
     110         480 :     entry.params = _data_params;
     111             : 
     112         480 :     if (!value.hasStoreJSON())
     113             :     {
     114          28 :       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          24 :       entry.params.value = false;
     125             :     }
     126             : 
     127         476 :     _values.emplace(value.name(), entry);
     128             :   }
     129         130 : }
     130             : 
     131             : void
     132         392 : to_json(nlohmann::json & json, const RestartableDataReporter::Value & value)
     133             : {
     134             :   mooseAssert(value.value, "Not set");
     135         392 :   value.value->store(json, value.params);
     136         392 : }