Loading [MathJax]/extensions/tex2jax.js
https://mooseframework.inl.gov
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends
Builder.C
Go to the documentation of this file.
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 // MOOSE includes
11 #include "MooseUtils.h"
12 #include "MooseInit.h"
13 #include "InputParameters.h"
14 #include "ActionFactory.h"
15 #include "Action.h"
16 #include "Factory.h"
17 #include "MooseObjectAction.h"
19 #include "ActionWarehouse.h"
20 #include "EmptyAction.h"
21 #include "FEProblem.h"
22 #include "MooseMesh.h"
23 #include "Executioner.h"
24 #include "MooseApp.h"
25 #include "MooseEnum.h"
26 #include "MultiMooseEnum.h"
27 #include "MultiApp.h"
28 #include "GlobalParamsAction.h"
29 #include "SyntaxTree.h"
30 #include "InputFileFormatter.h"
31 #include "YAMLFormatter.h"
32 #include "MooseTypes.h"
33 #include "CommandLine.h"
34 #include "JsonSyntaxTree.h"
35 #include "SystemInfo.h"
36 #include "MooseUtils.h"
37 #include "Conversion.h"
38 #include "Units.h"
39 #include "ActionComponent.h"
40 
41 #include "libmesh/parallel.h"
42 #include "libmesh/fparser.hh"
43 
44 // Regular expression includes
45 #include "pcrecpp.h"
46 
47 // C++ includes
48 #include <string>
49 #include <map>
50 #include <fstream>
51 #include <iomanip>
52 #include <algorithm>
53 #include <cstdlib>
54 #include <filesystem>
55 
56 namespace Moose
57 {
58 
59 bool
60 isSectionActive(std::string path, hit::Node * root)
61 {
62  hit::Node * n = root->find(path);
63  while (n)
64  {
65  hit::Node * section = n->parent();
66  if (section)
67  {
68  auto actives = section->find("active");
69  auto inactives = section->find("inactive");
70 
71  // only check current level, not nested ones
72  if (actives && actives->type() == hit::NodeType::Field && actives->parent() == section)
73  {
74  auto vars = section->param<std::vector<std::string>>("active");
75  bool have_var = false;
76  for (auto & var : vars)
77  if (n->path() == hit::pathNorm(var))
78  have_var = true;
79  if (!have_var)
80  return false;
81  }
82  // only check current level, not nested ones
83  if (inactives && inactives->type() == hit::NodeType::Field && inactives->parent() == section)
84  {
85  auto vars = section->param<std::vector<std::string>>("inactive");
86  for (auto & var : vars)
87  if (n->path() == hit::pathNorm(var))
88  return false;
89  }
90  }
91  n = section;
92  }
93  return true;
94 }
95 
96 std::vector<std::string>
97 findSimilar(std::string param, std::vector<std::string> options)
98 {
99  std::vector<std::string> candidates;
100  if (options.size() == 0)
101  return candidates;
102 
103  int mindist = MooseUtils::levenshteinDist(options[0], param);
104  for (auto & opt : options)
105  {
106  int dist = MooseUtils::levenshteinDist(opt, param);
107  // magic number heuristics to get similarity distance cutoff
108  int dist_cutoff = 1 + param.size() / 5;
109  if (dist > dist_cutoff || dist > mindist)
110  continue;
111 
112  if (dist < mindist)
113  {
114  mindist = dist;
115  candidates.clear();
116  }
117  candidates.push_back(opt);
118  }
119  return candidates;
120 }
121 
122 Builder::Builder(MooseApp & app, ActionWarehouse & action_wh, std::shared_ptr<Parser> parser)
123  : ConsoleStreamInterface(app),
124  _app(app),
125  _factory(app.getFactory()),
126  _action_wh(action_wh),
127  _action_factory(app.getActionFactory()),
128  _syntax(_action_wh.syntax()),
129  _parser(parser),
130  _syntax_formatter(nullptr),
131  _sections_read(false),
132  _current_params(nullptr),
133  _current_error_stream(nullptr)
134 {
135  mooseAssert(_parser, "Parser is not set");
136 }
137 
139 
142 {
144 
149  params.addParam<std::vector<std::string>>(
150  "active",
151  std::vector<std::string>({"__all__"}),
152  "If specified only the blocks named will be visited and made active");
153  params.addParam<std::vector<std::string>>(
154  "inactive",
155  std::vector<std::string>(),
156  "If specified blocks matching these identifiers will be skipped.");
157 
158  return params;
159 }
160 
161 std::vector<std::string>
162 Builder::listValidParams(std::string & section_name)
163 {
164  bool dummy;
165  std::string registered_identifier = _syntax.isAssociated(section_name, &dummy);
166  auto iters = _syntax.getActions(registered_identifier);
167 
168  std::vector<std::string> paramlist;
169  for (auto it = iters.first; it != iters.second; ++it)
170  {
171  auto params = _action_factory.getValidParams(it->second._action);
172  for (const auto & it : params)
173  paramlist.push_back(it.first);
174  }
175  return paramlist;
176 }
177 
178 void
179 UnusedWalker::walk(const std::string & fullpath, const std::string & nodename, hit::Node * n)
180 {
181  // the line() > 0 check allows us to skip nodes that were merged into this tree (i.e. CLI
182  // args) because their unused params are checked+reported independently of the ones in the
183  // main tree.
184  if (!_used.count(fullpath) && nodename != "active" && nodename != "inactive" &&
185  isSectionActive(fullpath, n->root()) && n->line() > 0)
186  {
187  auto section_name = fullpath.substr(0, fullpath.rfind("/"));
188  auto paramlist = _builder.listValidParams(section_name);
189  auto candidates = findSimilar(nodename, paramlist);
190  if (candidates.size() > 0)
191  errors.push_back(hit::errormsg(
192  n, "unused parameter '", fullpath, "'\n", " Did you mean '", candidates[0], "'?"));
193  else
194  errors.push_back(hit::errormsg(n, "unused parameter '", fullpath, "'"));
195  }
196 }
197 
198 std::string
199 Builder::getPrimaryFileName(bool strip_leading_path) const
200 {
201  const auto path = _parser->getLastInputFilePath();
202  return (strip_leading_path ? path.filename() : std::filesystem::absolute(path)).string();
203 }
204 
205 void
206 Builder::walkRaw(std::string /*fullpath*/, std::string /*nodepath*/, hit::Node * n)
207 {
208  InputParameters active_list_params = Action::validParams();
210 
211  std::string section_name = n->fullpath();
212  std::string curr_identifier = n->fullpath();
213 
214  // Before we retrieve any actions or build any objects, make sure that the section they are in
215  // is active
216  if (!isSectionActive(curr_identifier, root()))
217  return;
218 
219  // Extract the block parameters before constructing the action
220  // There may be more than one Action registered for a given section in which case we need to
221  // build them all
222  bool is_parent;
223  std::string registered_identifier = _syntax.isAssociated(section_name, &is_parent);
224 
225  // Make sure at least one action is associated with the current identifier
226  if (const auto [begin, end] = _syntax.getActions(registered_identifier); begin == end)
227  {
228  _errmsg += hit::errormsg(n,
229  "section '[",
230  curr_identifier,
231  "]' does not have an associated \"Action\".\n Common causes:\n"
232  "- you misspelled the Action/section name\n"
233  "- the app you are running does not support this Action/syntax") +
234  "\n";
235  return;
236  }
237 
238  // The DynamicObjecRegistrationAction changes the action multimap and would invalidate the
239  // iterators returned by _syntax.getActions, that's why we have to loop in this awkward way.
240  std::set<const Syntax::ActionInfo *> processed_actions;
241  while (true)
242  {
243  // search for an unprocessed action
244  auto [begin, end] = _syntax.getActions(registered_identifier);
245  auto it = begin;
246  for (; it != end && processed_actions.count(&it->second); ++it)
247  ;
248 
249  // no more unprocessed actions
250  if (it == end)
251  break;
252 
253  // mark action as processed
254  processed_actions.insert(&it->second);
255 
256  if (is_parent)
257  continue;
258  if (_syntax.isDeprecatedSyntax(registered_identifier))
260  hit::errormsg(n, _syntax.deprecatedActionSyntaxMessage(registered_identifier)));
261 
262  params = _action_factory.getValidParams(it->second._action);
263  params.set<ActionWarehouse *>("awh") = &_action_wh;
264  params.setHitNode(*n, {});
265 
266  extractParams(curr_identifier, params);
267 
268  // Add the parsed syntax to the parameters object for consumption by the Action
269  params.set<std::string>("task") = it->second._task;
270  params.set<std::string>("registered_identifier") = registered_identifier;
271 
272  if (!(params.have_parameter<bool>("isObjectAction") && params.get<bool>("isObjectAction")))
273  params.set<std::vector<std::string>>("control_tags")
274  .push_back(MooseUtils::baseName(curr_identifier));
275 
276  // Create the Action
277  std::shared_ptr<Action> action_obj =
278  _action_factory.create(it->second._action, curr_identifier, params);
279 
280  {
281  // extract the MooseObject params if necessary
282  std::shared_ptr<MooseObjectAction> object_action =
284  if (object_action)
285  {
286  auto & object_params = object_action->getObjectParams();
287  object_params.setHitNode(*n, {});
288  extractParams(curr_identifier, object_params);
289  object_params.set<std::vector<std::string>>("control_tags")
290  .push_back(MooseUtils::baseName(curr_identifier));
291  }
292  // extract the Component params if necessary
293  std::shared_ptr<AddActionComponentAction> component_action =
295  if (component_action)
296  {
297  auto & component_params = component_action->getComponentParams();
298  component_params.setHitNode(*n, {});
299  extractParams(curr_identifier, component_params);
300  component_params.set<std::vector<std::string>>("control_tags")
301  .push_back(MooseUtils::baseName(curr_identifier));
302  }
303  }
304 
305  // add it to the warehouse
306  _action_wh.addActionBlock(action_obj);
307  }
308 }
309 
310 void
311 Builder::walk(const std::string & fullpath, const std::string & nodepath, hit::Node * n)
312 {
313  // skip sections that were manually processed first.
314  for (auto & sec : _secs_need_first)
315  if (nodepath == sec)
316  return;
317  walkRaw(fullpath, nodepath, n);
318 }
319 
320 hit::Node *
322 {
323  mooseAssert(_parser, "Parser is not set");
324  return _parser->root();
325 }
326 
327 void
329 {
330  // add in command line arguments
331  const auto cli_input = _app.commandLine()->buildHitParams();
332  try
333  {
334  _cli_root.reset(hit::parse("CLI_ARGS", cli_input));
335  hit::explode(_cli_root.get());
336  hit::merge(_cli_root.get(), root());
337  }
338  catch (hit::ParseError & err)
339  {
340  mooseError(err.what());
341  }
342 
343  // expand ${bla} parameter values and mark/include variables used in expansions as "used". This
344  // MUST occur before parameter extraction - otherwise parameters will get wrong values.
345  hit::RawEvaler raw;
346  hit::EnvEvaler env;
347  hit::ReplaceEvaler repl;
348  FuncParseEvaler fparse_ev;
349  UnitsConversionEvaler units_ev;
350  hit::BraceExpander exw;
351  exw.registerEvaler("raw", raw);
352  exw.registerEvaler("env", env);
353  exw.registerEvaler("fparse", fparse_ev);
354  exw.registerEvaler("replace", repl);
355  exw.registerEvaler("units", units_ev);
356  root()->walk(&exw);
357  for (auto & var : exw.used)
358  _extracted_vars.insert(var);
359  for (auto & msg : exw.errors)
360  _errmsg += msg + "\n";
361 
362  // do as much error checking as early as possible so that errors are more useful instead
363  // of surprising and disconnected from what caused them.
364  DupParamWalker dw;
365  BadActiveWalker bw;
366  root()->walk(&dw, hit::NodeType::Field);
367  root()->walk(&bw, hit::NodeType::Section);
368  for (auto & msg : dw.errors)
369  _errmsg += msg + "\n";
370  for (auto & msg : bw.errors)
371  _errmsg += msg + "\n";
372 
373  // Print parse errors related to brace expansion early
374  if (_errmsg.size() > 0)
376 
377  // There are a few order dependent actions that have to be built first in
378  // order for the parser and application to function properly:
379  //
380  // SetupDebugAction: This action can contain an option for monitoring the parser progress. It must
381  // be parsed first to capture all of the parsing output.
382  //
383  // GlobalParamsAction: This action is checked during the parameter extraction routines of all
384  // subsequent blocks. It must be parsed early since it must exist during
385  // subsequent parameter extraction.
386  //
387  // DynamicObjectRegistration: This action must be built before any MooseObjectActions are built.
388  // This is because we retrieve valid parameters from the Factory
389  // during parse time. Objects must be registered before
390  // validParameters can be retrieved.
391  auto syntax = _syntax.getSyntaxByAction("SetupDebugAction");
392  std::copy(syntax.begin(), syntax.end(), std::back_inserter(_secs_need_first));
393 
394  syntax = _syntax.getSyntaxByAction("GlobalParamsAction");
395  std::copy(syntax.begin(), syntax.end(), std::back_inserter(_secs_need_first));
396 
397  syntax = _syntax.getSyntaxByAction("DynamicObjectRegistrationAction");
398  std::copy(syntax.begin(), syntax.end(), std::back_inserter(_secs_need_first));
399 
400  // walk all the sections extracting paramters from each into InputParameters objects
401  for (auto & sec : _secs_need_first)
402  {
403  auto n = root()->find(sec);
404  if (n)
405  walkRaw(n->parent()->fullpath(), n->path(), n);
406  }
407  root()->walk(this, hit::NodeType::Section);
408 
409  if (_errmsg.size() > 0)
411 }
412 
413 // Checks the input and the way it has been used and emits any errors/warnings.
414 // This has to be a separate function because for we don't know if some parameters were unused
415 // until all the multiapps/subapps have been fully initialized - which isn't complete until
416 // *after* all the other member functions on Parser have been run. So this is here to be
417 // externally called at the right time.
418 void
419 Builder::errorCheck(const Parallel::Communicator & comm, bool warn_unused, bool err_unused)
420 {
421  // this if guard is important in case the simulation was not configured via parsed input text -
422  // e.g. configured programatically.
423  if (!root() || !_cli_root)
424  return;
425 
426  UnusedWalker uw(_extracted_vars, *this);
427  UnusedWalker uwcli(_extracted_vars, *this);
428 
429  root()->walk(&uw);
430  _cli_root->walk(&uwcli);
431 
432  auto cli = _app.commandLine();
433  if (warn_unused)
434  {
435  for (const auto & arg : cli->unusedHitParams(comm))
436  _warnmsg +=
437  hit::errormsg("CLI_ARG", nullptr, "unused command line parameter '", arg, "'") + "\n";
438  for (auto & msg : uwcli.errors)
439  _warnmsg += msg + "\n";
440  for (auto & msg : uw.errors)
441  _warnmsg += msg + "\n";
442  }
443  else if (err_unused)
444  {
445  for (const auto & arg : cli->unusedHitParams(comm))
446  _errmsg +=
447  hit::errormsg("CLI_ARG", nullptr, "unused command line parameter '", arg, "'") + "\n";
448  for (auto & msg : uwcli.errors)
449  _errmsg += msg + "\n";
450  for (auto & msg : uw.errors)
451  _errmsg += msg + "\n";
452  }
453 
454  if (_warnmsg.size() > 0)
456  if (_errmsg.size() > 0)
457  mooseError(
458  _errmsg +
459  "\n\nAppend --allow-unused (or -w) on the command line to ignore unused parameters.");
460 }
461 
462 void
464 {
465  switch (type)
466  {
467  case INPUT_FILE:
468  _syntax_formatter = std::make_unique<InputFileFormatter>(dump_mode);
469  break;
470  case YAML:
471  _syntax_formatter = std::make_unique<YAMLFormatter>(dump_mode);
472  break;
473  default:
474  mooseError("Unrecognized Syntax Formatter requested");
475  break;
476  }
477 }
478 
479 void
481 {
482  std::vector<std::pair<std::string, Syntax::ActionInfo>> all_names;
483 
484  for (const auto & iter : _syntax.getAssociatedTypes())
485  root.addSyntaxType(iter.first, iter.second);
486 
487  // Build a list of all the actions appearing in the syntax
488  for (const auto & iter : _syntax.getAssociatedActions())
489  {
490  Syntax::ActionInfo act_info = iter.second;
496  if (act_info._task == "")
497  act_info._task = _action_factory.getTaskName(act_info._action);
498 
499  all_names.push_back(std::make_pair(iter.first, act_info));
500  }
501 
502  // Add all the actions to the JSON tree, except for ActionComponents (below)
503  for (const auto & act_names : all_names)
504  {
505  const auto & act_info = act_names.second;
506  const std::string & action = act_info._action;
507  const std::string & task = act_info._task;
508  const std::string syntax = act_names.first;
509  InputParameters action_obj_params = _action_factory.getValidParams(action);
510  bool params_added = root.addParameters("",
511  syntax,
512  false,
513  action,
514  true,
515  &action_obj_params,
516  _syntax.getLineInfo(syntax, action, ""),
517  "");
518 
519  if (params_added)
520  {
521  auto tasks = _action_factory.getTasksByAction(action);
522  for (auto & t : tasks)
523  {
524  auto info = _action_factory.getLineInfo(action, t);
525  root.addActionTask(syntax, action, t, info);
526  }
527  }
528 
534  if (action_obj_params.have_parameter<bool>("isObjectAction") &&
535  action_obj_params.get<bool>("isObjectAction"))
536  {
537  for (auto & [moose_obj_name, obj] : _factory.registeredObjects())
538  {
539  auto moose_obj_params = obj->buildParameters();
540  // Now that we know that this is a MooseObjectAction we need to see if it has been
541  // restricted
542  // in any way by the user.
543  const std::vector<std::string> & buildable_types = action_obj_params.getBuildableTypes();
544 
545  // See if the current Moose Object syntax belongs under this Action's block
546  if ((buildable_types.empty() || // Not restricted
547  std::find(buildable_types.begin(), buildable_types.end(), moose_obj_name) !=
548  buildable_types.end()) && // Restricted but found
549  moose_obj_params.have_parameter<std::string>("_moose_base") && // Has a registered base
550  _syntax.verifyMooseObjectTask(moose_obj_params.get<std::string>("_moose_base"),
551  task) && // and that base is associated
552  action_obj_params.mooseObjectSyntaxVisibility() // and the Action says it's visible
553  )
554  {
555  std::string name;
556  size_t pos = 0;
557  bool is_action_params = false;
558  bool is_type = false;
559  if (syntax[syntax.size() - 1] == '*')
560  {
561  pos = syntax.size();
562 
563  if (!action_obj_params.collapseSyntaxNesting())
564  name = syntax.substr(0, pos - 1) + moose_obj_name;
565  else
566  {
567  name = syntax.substr(0, pos - 1) + "/<type>/" + moose_obj_name;
568  is_action_params = true;
569  }
570  }
571  else
572  {
573  name = syntax + "/<type>/" + moose_obj_name;
574  is_type = true;
575  }
576  moose_obj_params.set<std::string>("type") = moose_obj_name;
577 
578  auto lineinfo = _factory.getLineInfo(moose_obj_name);
579  std::string classname = _factory.associatedClassName(moose_obj_name);
580  root.addParameters(syntax,
581  name,
582  is_type,
583  moose_obj_name,
584  is_action_params,
585  &moose_obj_params,
586  lineinfo,
587  classname);
588  }
589  }
590 
591  // Same thing for ActionComponents, which, while they are not MooseObjects, should behave
592  // similarly syntax-wise
593  if (syntax != "ActionComponents/*")
594  continue;
595 
596  auto iters = _action_factory.getActionsByTask("list_component");
597 
598  for (auto it = iters.first; it != iters.second; ++it)
599  {
600  // Get the name and parameters
601  const auto component_name = it->second;
602  auto component_params = _action_factory.getValidParams(component_name);
603 
604  // We currently do not have build-type restrictions on this action that adds
605  // action-components
606 
607  // See if the current Moose Object syntax belongs under this Action's block
608  if (action_obj_params.mooseObjectSyntaxVisibility() // and the Action says it's visible
609  )
610  {
611  // The logic for Components is a little simpler here for now because syntax like
612  // Executioner/TimeIntegrator/type= do not exist for components
613  std::string name;
614  if (syntax[syntax.size() - 1] == '*')
615  {
616  size_t pos = syntax.size();
617  name = syntax.substr(0, pos - 1) + component_name;
618  }
619  component_params.set<std::string>("type") = component_name;
620 
621  auto lineinfo = _action_factory.getLineInfo(component_name, "list_component");
622  // We add the parameters as for an object, because we want to fit them to be
623  // added to json["AddActionComponentAction"]["subblock_types"]
624  root.addParameters(syntax,
625  /*syntax_path*/ name,
626  /*is_type*/ false,
627  "AddActionComponentAction",
628  /*is_action=*/false,
629  &component_params,
630  lineinfo,
631  component_name);
632  }
633  }
634  }
635  }
636  root.addGlobal();
637 }
638 
639 void
640 Builder::buildFullTree(const std::string & search_string)
641 {
642  std::vector<std::pair<std::string, Syntax::ActionInfo>> all_names;
643 
644  for (const auto & iter : _syntax.getAssociatedActions())
645  {
646  Syntax::ActionInfo act_info = iter.second;
652  if (act_info._task == "")
653  act_info._task = _action_factory.getTaskName(act_info._action);
654 
655  all_names.push_back(std::pair<std::string, Syntax::ActionInfo>(iter.first, act_info));
656  }
657 
658  for (const auto & act_names : all_names)
659  {
660  InputParameters action_obj_params = _action_factory.getValidParams(act_names.second._action);
661  _syntax_formatter->insertNode(
662  act_names.first, act_names.second._action, true, &action_obj_params);
663 
664  const std::string & task = act_names.second._task;
665  std::string act_name = act_names.first;
666 
672  if (action_obj_params.have_parameter<bool>("isObjectAction") &&
673  action_obj_params.get<bool>("isObjectAction"))
674  {
675  for (const auto & [moose_obj_name, obj] : _factory.registeredObjects())
676  {
677  auto moose_obj_params = obj->buildParameters();
682  const std::vector<std::string> & buildable_types = action_obj_params.getBuildableTypes();
683 
684  // See if the current Moose Object syntax belongs under this Action's block
685  if ((buildable_types.empty() || // Not restricted
686  std::find(buildable_types.begin(), buildable_types.end(), moose_obj_name) !=
687  buildable_types.end()) && // Restricted but found
688  moose_obj_params.have_parameter<std::string>("_moose_base") && // Has a registered base
689  _syntax.verifyMooseObjectTask(moose_obj_params.get<std::string>("_moose_base"),
690  task) && // and that base is associated
691  action_obj_params.mooseObjectSyntaxVisibility() // and the Action says it's visible
692  )
693  {
694  std::string name;
695  size_t pos = 0;
696  bool is_action_params = false;
697  if (act_name[act_name.size() - 1] == '*')
698  {
699  pos = act_name.size();
700 
701  if (!action_obj_params.collapseSyntaxNesting())
702  name = act_name.substr(0, pos - 1) + moose_obj_name;
703  else
704  {
705  name = act_name.substr(0, pos - 1) + "/<type>/" + moose_obj_name;
706  is_action_params = true;
707  }
708  }
709  else
710  {
711  name = act_name + "/<type>/" + moose_obj_name;
712  }
713 
714  moose_obj_params.set<std::string>("type") = moose_obj_name;
715 
716  _syntax_formatter->insertNode(name, moose_obj_name, is_action_params, &moose_obj_params);
717  }
718  }
719  }
720  }
721 
722  // Do not change to _console, we need this printed to the stdout in all cases
723  Moose::out << _syntax_formatter->print(search_string) << std::flush;
724 }
725 
726 /**************************************************************************************************
727  **************************************************************************************************
728  * Parameter Extraction Routines *
729  **************************************************************************************************
730  **************************************************************************************************/
731 using std::string;
732 
733 // Template Specializations for retrieving special types from the input file
734 template <>
735 void Builder::setScalarParameter<RealVectorValue, RealVectorValue>(
736  const std::string & full_name,
737  const std::string & short_name,
738  InputParameters::Parameter<RealVectorValue> * param,
739  bool in_global,
740  GlobalParamsAction * global_block);
741 
742 template <>
743 void Builder::setScalarParameter<Point, Point>(const std::string & full_name,
744  const std::string & short_name,
745  InputParameters::Parameter<Point> * param,
746  bool in_global,
747  GlobalParamsAction * global_block);
748 
749 template <>
750 void Builder::setScalarParameter<RealEigenVector, RealEigenVector>(
751  const std::string & full_name,
752  const std::string & short_name,
753  InputParameters::Parameter<RealEigenVector> * param,
754  bool in_global,
755  GlobalParamsAction * global_block);
756 
757 template <>
758 void Builder::setScalarParameter<RealEigenMatrix, RealEigenMatrix>(
759  const std::string & full_name,
760  const std::string & short_name,
761  InputParameters::Parameter<RealEigenMatrix> * param,
762  bool in_global,
763  GlobalParamsAction * global_block);
764 
765 template <>
766 void Builder::setScalarParameter<PostprocessorName, PostprocessorName>(
767  const std::string & full_name,
768  const std::string & short_name,
769  InputParameters::Parameter<PostprocessorName> * param,
770  bool in_global,
771  GlobalParamsAction * global_block);
772 
773 template <>
774 void
775 Builder::setScalarParameter<MooseEnum, MooseEnum>(const std::string & full_name,
776  const std::string & short_name,
777  InputParameters::Parameter<MooseEnum> * param,
778  bool in_global,
779  GlobalParamsAction * global_block);
780 
781 template <>
782 void Builder::setScalarParameter<MultiMooseEnum, MultiMooseEnum>(
783  const std::string & full_name,
784  const std::string & short_name,
785  InputParameters::Parameter<MultiMooseEnum> * param,
786  bool in_global,
787  GlobalParamsAction * global_block);
788 
789 template <>
790 void Builder::setScalarParameter<ExecFlagEnum, ExecFlagEnum>(
791  const std::string & full_name,
792  const std::string & short_name,
793  InputParameters::Parameter<ExecFlagEnum> * param,
794  bool in_global,
795  GlobalParamsAction * global_block);
796 
797 template <>
798 void Builder::setScalarParameter<RealTensorValue, RealTensorValue>(
799  const std::string & full_name,
800  const std::string & short_name,
801  InputParameters::Parameter<RealTensorValue> * param,
802  bool in_global,
803  GlobalParamsAction * global_block);
804 
805 template <>
806 void Builder::setScalarParameter<ReporterName, std::string>(
807  const std::string & full_name,
808  const std::string & short_name,
809  InputParameters::Parameter<ReporterName> * param,
810  bool in_global,
811  GlobalParamsAction * global_block);
812 
813 // Vectors
814 template <>
815 void Builder::setVectorParameter<RealVectorValue, RealVectorValue>(
816  const std::string & full_name,
817  const std::string & short_name,
818  InputParameters::Parameter<std::vector<RealVectorValue>> * param,
819  bool in_global,
820  GlobalParamsAction * global_block);
821 
822 template <>
823 void
824 Builder::setVectorParameter<Point, Point>(const std::string & full_name,
825  const std::string & short_name,
826  InputParameters::Parameter<std::vector<Point>> * param,
827  bool in_global,
828  GlobalParamsAction * global_block);
829 
830 template <>
831 void Builder::setVectorParameter<PostprocessorName, PostprocessorName>(
832  const std::string & full_name,
833  const std::string & short_name,
834  InputParameters::Parameter<std::vector<PostprocessorName>> * param,
835  bool in_global,
836  GlobalParamsAction * global_block);
837 
838 template <>
839 void Builder::setVectorParameter<MooseEnum, MooseEnum>(
840  const std::string & full_name,
841  const std::string & short_name,
842  InputParameters::Parameter<std::vector<MooseEnum>> * param,
843  bool in_global,
844  GlobalParamsAction * global_block);
845 
846 template <>
847 void Builder::setVectorParameter<MultiMooseEnum, MultiMooseEnum>(
848  const std::string & full_name,
849  const std::string & short_name,
850  InputParameters::Parameter<std::vector<MultiMooseEnum>> * param,
851  bool in_global,
852  GlobalParamsAction * global_block);
853 
854 template <>
855 void Builder::setVectorParameter<VariableName, VariableName>(
856  const std::string & full_name,
857  const std::string & short_name,
858  InputParameters::Parameter<std::vector<VariableName>> * param,
859  bool in_global,
860  GlobalParamsAction * global_block);
861 
862 template <>
863 void Builder::setVectorParameter<ReporterName, std::string>(
864  const std::string & full_name,
865  const std::string & short_name,
866  InputParameters::Parameter<std::vector<ReporterName>> * param,
867  bool in_global,
868  GlobalParamsAction * global_block);
869 
870 template <>
871 void Builder::setVectorParameter<CLIArgString, std::string>(
872  const std::string & full_name,
873  const std::string & short_name,
874  InputParameters::Parameter<std::vector<CLIArgString>> * param,
875  bool in_global,
876  GlobalParamsAction * global_block);
877 
878 template <>
879 void Builder::setDoubleIndexParameter<Point>(
880  const std::string & full_name,
881  const std::string & short_name,
882  InputParameters::Parameter<std::vector<std::vector<Point>>> * param,
883  bool in_global,
884  GlobalParamsAction * global_block);
885 
886 void
887 Builder::extractParams(const std::string & prefix, InputParameters & p)
888 {
889  std::ostringstream error_stream;
890  static const std::string global_params_task = "set_global_params";
891  static const std::string global_params_block_name =
892  _syntax.getSyntaxByAction("GlobalParamsAction").front();
893 
894  ActionIterator act_iter = _action_wh.actionBlocksWithActionBegin(global_params_task);
895  GlobalParamsAction * global_params_block = nullptr;
896 
897  // We are grabbing only the first
898  if (act_iter != _action_wh.actionBlocksWithActionEnd(global_params_task))
899  global_params_block = dynamic_cast<GlobalParamsAction *>(*act_iter);
900 
901  // Set a pointer to the current InputParameters object being parsed so that it can be referred
902  // to
903  // in the extraction routines
904  _current_params = &p;
905  _current_error_stream = &error_stream;
906  for (const auto & it : p)
907  {
908  if (p.shouldIgnore(it.first))
909  continue;
910 
911  bool found = false;
912  bool in_global = false;
913 
914  for (const auto & param_name : p.paramAliases(it.first))
915  {
916  std::string orig_name = prefix + "/" + param_name;
917  std::string full_name = orig_name;
918 
919  // Mark parameters appearing in the input file or command line
920  auto node = root()->find(full_name);
921  if (node && node->type() == hit::NodeType::Field)
922  {
923  p.setHitNode(param_name, *node, {});
924  p.set_attributes(param_name, false);
925  // Check if we have already printed the deprecated param message.
926  // If we haven't, add it to the tracker, and print it.
927  if (!_deprec_param_tracker.count(param_name))
928  if (p.attemptPrintDeprecated(param_name))
929  _deprec_param_tracker.insert(param_name);
930  _extracted_vars.insert(
931  full_name); // Keep track of all variables extracted from the input file
932  found = true;
933  }
934  // Wait! Check the GlobalParams section
935  else if (global_params_block)
936  {
937  full_name = global_params_block_name + "/" + param_name;
938  node = root()->find(full_name);
939  if (node)
940  {
941  p.setHitNode(param_name, *node, {});
942  p.set_attributes(param_name, false);
943  _extracted_vars.insert(
944  full_name); // Keep track of all variables extracted from the input file
945  found = true;
946  in_global = true;
947  }
948  }
949  if (found)
950  {
951  if (p.isPrivate(param_name) && !in_global)
952  mooseError("The parameter '",
953  full_name,
954  "' is a private parameter and should not be used in an input file.");
955  // avoid setting the parameter
956  else if (p.isPrivate(param_name) && in_global)
957  continue;
958 
959  auto & short_name = param_name;
960  libMesh::Parameters::Value * par = MooseUtils::get(it.second);
961 
962 #define setscalarvaltype(ptype, base, range) \
963  else if (par->type() == demangle(typeid(ptype).name())) \
964  setScalarValueTypeParameter<ptype, range, base>( \
965  full_name, \
966  short_name, \
967  dynamic_cast<InputParameters::Parameter<ptype> *>(par), \
968  in_global, \
969  global_params_block)
970 #define setscalar(ptype, base) \
971  else if (par->type() == demangle(typeid(ptype).name())) \
972  setScalarParameter<ptype, base>(full_name, \
973  short_name, \
974  dynamic_cast<InputParameters::Parameter<ptype> *>(par), \
975  in_global, \
976  global_params_block)
977 #define setvector(ptype, base) \
978  else if (par->type() == demangle(typeid(std::vector<ptype>).name())) \
979  setVectorParameter<ptype, base>( \
980  full_name, \
981  short_name, \
982  dynamic_cast<InputParameters::Parameter<std::vector<ptype>> *>(par), \
983  in_global, \
984  global_params_block)
985 #define setmap(key_type, mapped_type) \
986  else if (par->type() == demangle(typeid(std::map<key_type, mapped_type>).name())) \
987  setMapParameter( \
988  full_name, \
989  short_name, \
990  dynamic_cast<InputParameters::Parameter<std::map<key_type, mapped_type>> *>(par), \
991  in_global, \
992  global_params_block)
993 #define setvectorvector(ptype) \
994  else if (par->type() == demangle(typeid(std::vector<std::vector<ptype>>).name())) \
995  setDoubleIndexParameter<ptype>( \
996  full_name, \
997  short_name, \
998  dynamic_cast<InputParameters::Parameter<std::vector<std::vector<ptype>>> *>(par), \
999  in_global, \
1000  global_params_block)
1001 #define setvectorvectorvector(ptype) \
1002  else if (par->type() == demangle(typeid(std::vector<std::vector<std::vector<ptype>>>).name())) \
1003  setTripleIndexParameter<ptype>( \
1004  full_name, \
1005  short_name, \
1006  dynamic_cast< \
1007  InputParameters::Parameter<std::vector<std::vector<std::vector<ptype>>>> *>(par), \
1008  in_global, \
1009  global_params_block)
1010 
1014  // built-ins
1015  // NOTE: Similar dynamic casting is done in InputParameters.C, please update appropriately
1016  if (false)
1017  ;
1018  setscalarvaltype(Real, double, Real);
1019  setscalarvaltype(int, int, long);
1020  setscalarvaltype(unsigned short, unsigned int, long);
1021  setscalarvaltype(long, int, long);
1022  setscalarvaltype(unsigned int, unsigned int, long);
1023  setscalarvaltype(unsigned long, unsigned int, long);
1024  setscalarvaltype(long int, int64_t, long);
1025  setscalarvaltype(unsigned long long, unsigned int, long);
1026 
1027  setscalar(bool, bool);
1028  setscalar(SubdomainID, int);
1029  setscalar(BoundaryID, int);
1030 
1031  // string and string-subclass types
1032  setscalar(string, string);
1033  setscalar(SubdomainName, string);
1034  setscalar(BoundaryName, string);
1035  setscalar(FileName, string);
1036  setscalar(MeshFileName, string);
1037  setscalar(MatrixFileName, string);
1038  setscalar(FileNameNoExtension, string);
1039  setscalar(RelativeFileName, string);
1040  setscalar(DataFileName, string);
1041  setscalar(ComponentName, string);
1042  setscalar(PhysicsName, string);
1043  setscalar(OutFileBase, string);
1044  setscalar(VariableName, string);
1045  setscalar(NonlinearVariableName, string);
1046  setscalar(LinearVariableName, string);
1047  setscalar(SolverVariableName, string);
1048  setscalar(AuxVariableName, string);
1049  setscalar(FunctionName, string);
1050  setscalar(ConvergenceName, string);
1051  setscalar(MeshDivisionName, string);
1052  setscalar(UserObjectName, string);
1053  setscalar(VectorPostprocessorName, string);
1054  setscalar(IndicatorName, string);
1055  setscalar(MarkerName, string);
1056  setscalar(MultiAppName, string);
1057  setscalar(OutputName, string);
1058  setscalar(MaterialPropertyName, string);
1059  setscalar(MooseFunctorName, string);
1060  setscalar(MaterialName, string);
1061  setscalar(DistributionName, string);
1062  setscalar(PositionsName, string);
1063  setscalar(SamplerName, string);
1064  setscalar(TagName, string);
1065  setscalar(TimesName, string);
1066  setscalar(MeshGeneratorName, string);
1067  setscalar(ExtraElementIDName, string);
1068  setscalar(PostprocessorName, PostprocessorName);
1069  setscalar(ExecutorName, string);
1070  setscalar(NonlinearSystemName, string);
1071  setscalar(LinearSystemName, string);
1072  setscalar(SolverSystemName, string);
1073  setscalar(CLIArgString, string);
1074 
1075  // Moose Compound Scalars
1076  setscalar(RealVectorValue, RealVectorValue);
1077  setscalar(Point, Point);
1078  setscalar(RealEigenVector, RealEigenVector);
1079  setscalar(RealEigenMatrix, RealEigenMatrix);
1080  setscalar(MooseEnum, MooseEnum);
1081  setscalar(MultiMooseEnum, MultiMooseEnum);
1082  setscalar(RealTensorValue, RealTensorValue);
1083  setscalar(ExecFlagEnum, ExecFlagEnum);
1084  setscalar(ReporterName, string);
1085  setscalar(ReporterValueName, string);
1086  setscalar(ParsedFunctionExpression, string);
1087 
1088  // vector types
1089  setvector(bool, bool);
1090  setvector(Real, double);
1091  setvector(int, int);
1092  setvector(long, int);
1093  setvector(unsigned int, int);
1094 
1095 // We need to be able to parse 8-byte unsigned types when
1096 // libmesh is configured --with-dof-id-bytes=8. Officially,
1097 // libmesh uses uint64_t in that scenario, which is usually
1098 // equivalent to 'unsigned long long'. Note that 'long long'
1099 // has been around since C99 so most C++ compilers support it,
1100 // but presumably uint64_t is the "most standard" way to get a
1101 // 64-bit unsigned type, so we'll stick with that here.
1102 #if LIBMESH_DOF_ID_BYTES == 8
1103  setvector(uint64_t, int);
1104 #endif
1105 
1106  setvector(SubdomainID, int);
1107  setvector(BoundaryID, int);
1108  setvector(RealVectorValue, RealVectorValue);
1109  setvector(Point, Point);
1110  setvector(MooseEnum, MooseEnum);
1111  setvector(MultiMooseEnum, MultiMooseEnum);
1112 
1113  setvector(string, string);
1114  setvector(FileName, string);
1115  setvector(FileNameNoExtension, string);
1116  setvector(RelativeFileName, string);
1117  setvector(DataFileName, string);
1118  setvector(MeshFileName, string);
1119  setvector(MatrixFileName, string);
1120  setvector(SubdomainName, string);
1121  setvector(BoundaryName, string);
1122  setvector(NonlinearVariableName, string);
1123  setvector(LinearVariableName, string);
1124  setvector(SolverVariableName, string);
1125  setvector(AuxVariableName, string);
1126  setvector(FunctionName, string);
1127  setvector(ConvergenceName, string);
1128  setvector(MeshDivisionName, string);
1129  setvector(UserObjectName, string);
1130  setvector(IndicatorName, string);
1131  setvector(MarkerName, string);
1132  setvector(MultiAppName, string);
1133  setvector(PostprocessorName, PostprocessorName);
1134  setvector(VectorPostprocessorName, string);
1135  setvector(OutputName, string);
1136  setvector(MaterialPropertyName, string);
1137  setvector(MooseFunctorName, string);
1138  setvector(MaterialName, string);
1139  setvector(DistributionName, string);
1140  setvector(SamplerName, string);
1141  setvector(TagName, string);
1142  setvector(VariableName, VariableName);
1143  setvector(MeshGeneratorName, string);
1144  setvector(ExtraElementIDName, string);
1145  setvector(ReporterName, string);
1146  setvector(CLIArgString, string);
1147  setvector(ComponentName, string);
1148  setvector(PhysicsName, string);
1149  setvector(PositionsName, string);
1150  setvector(TimesName, string);
1151  setvector(ReporterValueName, string);
1152  setvector(ExecutorName, string);
1153  setvector(NonlinearSystemName, string);
1154  setvector(LinearSystemName, string);
1155  setvector(SolverSystemName, string);
1156 
1157  // map types
1158  setmap(string, unsigned int);
1159  setmap(string, Real);
1160  setmap(string, string);
1161  setmap(unsigned int, unsigned int);
1162  setmap(unsigned long, unsigned int);
1163  setmap(unsigned long long, unsigned int);
1164 
1165  // Double indexed types
1166  setvectorvector(Real);
1167  setvectorvector(int);
1168  setvectorvector(long);
1169  setvectorvector(unsigned int);
1170  setvectorvector(unsigned long long);
1171 
1172 // See vector type explanation
1173 #if LIBMESH_DOF_ID_BYTES == 8
1174  setvectorvector(uint64_t);
1175 #endif
1176 
1177  setvectorvector(SubdomainID);
1178  setvectorvector(BoundaryID);
1179  setvectorvector(Point);
1180  setvectorvector(string);
1181  setvectorvector(FileName);
1182  setvectorvector(FileNameNoExtension);
1183  setvectorvector(DataFileName);
1184  setvectorvector(MeshFileName);
1185  setvectorvector(MatrixFileName);
1186  setvectorvector(SubdomainName);
1187  setvectorvector(BoundaryName);
1188  setvectorvector(VariableName);
1189  setvectorvector(NonlinearVariableName);
1190  setvectorvector(LinearVariableName);
1191  setvectorvector(SolverVariableName);
1192  setvectorvector(AuxVariableName);
1193  setvectorvector(FunctionName);
1194  setvectorvector(ConvergenceName);
1195  setvectorvector(UserObjectName);
1196  setvectorvector(IndicatorName);
1197  setvectorvector(MarkerName);
1198  setvectorvector(MultiAppName);
1199  setvectorvector(PostprocessorName);
1200  setvectorvector(VectorPostprocessorName);
1201  setvectorvector(MarkerName);
1202  setvectorvector(OutputName);
1203  setvectorvector(MaterialPropertyName);
1204  setvectorvector(MooseFunctorName);
1205  setvectorvector(MaterialName);
1206  setvectorvector(DistributionName);
1207  setvectorvector(SamplerName);
1208  setvectorvector(TagName);
1209 
1210  // Triple indexed types
1211  setvectorvectorvector(Real);
1212  setvectorvectorvector(int);
1213  setvectorvectorvector(long);
1214  setvectorvectorvector(unsigned int);
1215  setvectorvectorvector(unsigned long long);
1216 
1217 // See vector type explanation
1218 #if LIBMESH_DOF_ID_BYTES == 8
1219  setvectorvectorvector(uint64_t);
1220 #endif
1221 
1222  setvectorvectorvector(SubdomainID);
1223  setvectorvectorvector(BoundaryID);
1224  setvectorvectorvector(string);
1225  setvectorvectorvector(FileName);
1226  setvectorvectorvector(FileNameNoExtension);
1227  setvectorvectorvector(DataFileName);
1228  setvectorvectorvector(MeshFileName);
1229  setvectorvectorvector(MatrixFileName);
1230  setvectorvectorvector(SubdomainName);
1231  setvectorvectorvector(BoundaryName);
1232  setvectorvectorvector(VariableName);
1233  setvectorvectorvector(NonlinearVariableName);
1234  setvectorvectorvector(LinearVariableName);
1235  setvectorvectorvector(AuxVariableName);
1236  setvectorvectorvector(FunctionName);
1237  setvectorvectorvector(UserObjectName);
1238  setvectorvectorvector(IndicatorName);
1239  setvectorvectorvector(MarkerName);
1240  setvectorvectorvector(MultiAppName);
1241  setvectorvectorvector(PostprocessorName);
1242  setvectorvectorvector(VectorPostprocessorName);
1243  setvectorvectorvector(MarkerName);
1244  setvectorvectorvector(OutputName);
1245  setvectorvectorvector(MaterialPropertyName);
1246  setvectorvectorvector(MooseFunctorName);
1247  setvectorvectorvector(MaterialName);
1248  setvectorvectorvector(DistributionName);
1249  setvectorvectorvector(SamplerName);
1250  else
1251  {
1252  mooseError("unsupported type '", par->type(), "' for input parameter '", full_name, "'");
1253  }
1254 
1255 #undef setscalarValueType
1256 #undef setscalar
1257 #undef setvector
1258 #undef setvectorvectorvector
1259 #undef setvectorvector
1260 #undef setmap
1261  break;
1262  }
1263  }
1264 
1265  if (!found)
1266  {
1273  // In the case where we have OutFileName but it wasn't actually found in the input filename,
1274  // we will populate it with the actual parsed filename which is available here in the
1275  // parser.
1276 
1277  InputParameters::Parameter<OutFileBase> * scalar_p =
1278  dynamic_cast<InputParameters::Parameter<OutFileBase> *>(MooseUtils::get(it.second));
1279  if (scalar_p)
1280  {
1281  std::string input_file_name = getPrimaryFileName();
1282  mooseAssert(input_file_name != "", "Input Filename is nullptr");
1283  size_t pos = input_file_name.find_last_of('.');
1284  mooseAssert(pos != std::string::npos, "Unable to determine suffix of input file name");
1285  scalar_p->set() = input_file_name.substr(0, pos) + "_out";
1286  p.set_attributes(it.first, false);
1287  }
1288  }
1289  }
1290 
1291  // All of the parameters for this object have been extracted. See if there are any errors
1292  if (!error_stream.str().empty())
1293  mooseError(_errmsg + error_stream.str());
1294 
1295  // Here we will see if there are any auto build vectors that need to be created
1296  std::map<std::string, std::pair<std::string, std::string>> auto_build_vectors =
1297  p.getAutoBuildVectors();
1298  for (const auto & it : auto_build_vectors)
1299  {
1300  // We'll autogenerate values iff the requested vector is not valid but both the base and
1301  // number
1302  // are valid
1303  const std::string & base_name = it.second.first;
1304  const std::string & num_repeat = it.second.second;
1305 
1306  if (!p.isParamValid(it.first) && p.isParamValid(base_name) && p.isParamValid(num_repeat))
1307  {
1308  unsigned int vec_size = p.get<unsigned int>(num_repeat);
1309  const std::string & name = p.get<std::string>(base_name);
1310 
1311  std::vector<VariableName> variable_names(vec_size);
1312  for (unsigned int i = 0; i < vec_size; ++i)
1313  {
1314  std::ostringstream oss;
1315  oss << name << i;
1316  variable_names[i] = oss.str();
1317  }
1318 
1319  // Finally set the autogenerated vector into the InputParameters object
1320  p.set<std::vector<VariableName>>(it.first) = variable_names;
1321  }
1322  }
1323 }
1324 
1325 template <typename T>
1326 bool
1327 toBool(const std::string & /*s*/, T & /*val*/)
1328 {
1329  return false;
1330 }
1331 
1332 template <>
1333 bool
1334 toBool<bool>(const std::string & s, bool & val)
1335 {
1336  return hit::toBool(s, &val);
1337 }
1338 
1339 template <typename T, typename Base>
1340 void
1341 Builder::setScalarParameter(const std::string & full_name,
1342  const std::string & short_name,
1343  InputParameters::Parameter<T> * param,
1344  bool in_global,
1345  GlobalParamsAction * global_block)
1346 {
1347  try
1348  {
1349  param->set() = root()->param<Base>(full_name);
1350  }
1351  catch (hit::Error & err)
1352  {
1353  auto strval = root()->param<std::string>(full_name);
1354 
1355  // handle the case where the user put a number inside quotes
1356  auto & t = typeid(T);
1357  if (t == typeid(int) || t == typeid(unsigned int) || t == typeid(SubdomainID) ||
1358  t == typeid(BoundaryID) || t == typeid(double))
1359  {
1360  try
1361  {
1362  param->set() = MooseUtils::convert<T>(strval, true);
1363  }
1364  catch (std::invalid_argument & /*e*/)
1365  {
1366  const std::string format_type = (t == typeid(double)) ? "float" : "integer";
1367  _errmsg += hit::errormsg(root()->find(full_name),
1368  "invalid ",
1369  format_type,
1370  " syntax for parameter: ",
1371  full_name,
1372  "=",
1373  strval) +
1374  "\n";
1375  }
1376  }
1377  else if (t == typeid(bool))
1378  {
1379  bool isbool = toBool(strval, param->set());
1380  if (!isbool)
1381  _errmsg += hit::errormsg(root()->find(full_name),
1382  "invalid boolean syntax for parameter: ",
1383  full_name,
1384  "=",
1385  strval) +
1386  "\n";
1387  }
1388  else
1389  throw;
1390  }
1391 
1392  if (in_global)
1393  {
1394  global_block->remove(short_name);
1395  global_block->setScalarParam<T>(short_name) = param->get();
1396  }
1397 }
1398 
1399 template <typename T, typename UP_T, typename Base>
1400 void
1401 Builder::setScalarValueTypeParameter(const std::string & full_name,
1402  const std::string & short_name,
1403  InputParameters::Parameter<T> * param,
1404  bool in_global,
1405  GlobalParamsAction * global_block)
1406 {
1407  setScalarParameter<T, Base>(full_name, short_name, param, in_global, global_block);
1408 
1409  // If this is a range checked param, we need to make sure that the value falls within the
1410  // requested range
1411  mooseAssert(_current_params, "Current params is nullptr");
1412 
1413  _current_params->rangeCheck<T, UP_T>(full_name, short_name, param, *_current_error_stream);
1414 }
1415 
1416 template <typename T, typename Base>
1417 void
1418 Builder::setVectorParameter(const std::string & full_name,
1419  const std::string & short_name,
1420  InputParameters::Parameter<std::vector<T>> * param,
1421  bool in_global,
1422  GlobalParamsAction * global_block)
1423 {
1424  std::vector<T> vec;
1425  if (root()->find(full_name))
1426  {
1427  try
1428  {
1429  auto tmp = root()->param<std::vector<Base>>(full_name);
1430  for (auto val : tmp)
1431  vec.push_back(val);
1432  }
1433  catch (hit::Error & err)
1434  {
1435  _errmsg += hit::errormsg(root()->find(full_name), err.what()) + "\n";
1436  return;
1437  }
1438  }
1439 
1440  param->set() = vec;
1441 
1442  if (in_global)
1443  {
1444  global_block->remove(short_name);
1445  global_block->setVectorParam<T>(short_name).resize(param->get().size());
1446  for (unsigned int i = 0; i < vec.size(); ++i)
1447  global_block->setVectorParam<T>(short_name)[i] = param->get()[i];
1448  }
1449 }
1450 
1451 template <typename KeyType, typename MappedType>
1452 void
1453 Builder::setMapParameter(const std::string & full_name,
1454  const std::string & short_name,
1455  InputParameters::Parameter<std::map<KeyType, MappedType>> * param,
1456  bool in_global,
1457  GlobalParamsAction * global_block)
1458 {
1459  std::map<KeyType, MappedType> the_map;
1460  if (root()->find(full_name))
1461  {
1462  try
1463  {
1464  const auto & string_vec = root()->param<std::vector<std::string>>(full_name);
1465  auto it = string_vec.begin();
1466  while (it != string_vec.end())
1467  {
1468  const auto & string_key = *it;
1469  ++it;
1470  if (it == string_vec.end())
1471  {
1472  _errmsg +=
1473  hit::errormsg(root()->find(full_name),
1474  "odd number of entries in string vector for map parameter: ",
1475  full_name,
1476  ". There must be "
1477  "an even number or else you will end up with a key without a value!") +
1478  "\n";
1479  return;
1480  }
1481  const auto & string_value = *it;
1482  ++it;
1483 
1484  std::pair<KeyType, MappedType> pr;
1485  // key
1486  try
1487  {
1488  pr.first = MooseUtils::convert<KeyType>(string_key, true);
1489  }
1490  catch (std::invalid_argument & /*e*/)
1491  {
1492  _errmsg += hit::errormsg(root()->find(full_name),
1493  "invalid ",
1494  demangle(typeid(KeyType).name()),
1495  " syntax for map parameter ",
1496  full_name,
1497  " key: ",
1498  string_key) +
1499  "\n";
1500  return;
1501  }
1502  // value
1503  try
1504  {
1505  pr.second = MooseUtils::convert<MappedType>(string_value, true);
1506  }
1507  catch (std::invalid_argument & /*e*/)
1508  {
1509  _errmsg += hit::errormsg(root()->find(full_name),
1510  "invalid ",
1511  demangle(typeid(MappedType).name()),
1512  " syntax for map parameter ",
1513  full_name,
1514  " value: ",
1515  string_value) +
1516  "\n";
1517  return;
1518  }
1519 
1520  auto insert_pr = the_map.insert(std::move(pr));
1521  if (!insert_pr.second)
1522  {
1523  _errmsg += hit::errormsg(root()->find(full_name),
1524  "Duplicate map entry for map parameter: ",
1525  full_name,
1526  ". The key ",
1527  string_key,
1528  " appears multiple times.") +
1529  "\n";
1530  return;
1531  }
1532  }
1533  }
1534  catch (hit::Error & err)
1535  {
1536  _errmsg += hit::errormsg(root()->find(full_name), err.what()) + "\n";
1537  return;
1538  }
1539  }
1540 
1541  param->set() = the_map;
1542 
1543  if (in_global)
1544  {
1545  global_block->remove(short_name);
1546  auto & global_map = global_block->setParam<std::map<KeyType, MappedType>>(short_name);
1547  for (const auto & pair : the_map)
1548  global_map.insert(pair);
1549  }
1550 }
1551 
1552 template <typename T>
1553 void
1554 Builder::setDoubleIndexParameter(const std::string & full_name,
1555  const std::string & short_name,
1556  InputParameters::Parameter<std::vector<std::vector<T>>> * param,
1557  bool in_global,
1558  GlobalParamsAction * global_block)
1559 {
1560  auto & value = param->set();
1561 
1562  // Get the full string assigned to the variable full_name
1563  const auto value_string = MooseUtils::trim(root()->param<std::string>(full_name));
1564 
1565  // split vector at delim ;
1566  // NOTE: the substrings are _not_ of type T yet
1567  // The zero length here is intentional, as we want something like:
1568  // "abc; 123;" -> ["abc", "123", ""]
1569  std::vector<std::string> outer_string_vectors;
1570  // With split, we will get a single entry if the string value is empty. However,
1571  // that should represent an empty vector<vector>. Therefore, only split if we have values.
1572  if (!value_string.empty())
1573  outer_string_vectors = MooseUtils::split(value_string, ";");
1574 
1575  const auto outer_vector_size = outer_string_vectors.size();
1576  value.resize(outer_vector_size);
1577 
1578  for (const auto j : index_range(outer_string_vectors))
1579  if (!MooseUtils::tokenizeAndConvert<T>(outer_string_vectors[j], value[j]))
1580  {
1581  _errmsg +=
1582  hit::errormsg(root()->find(full_name), "invalid format for parameter ", full_name) + "\n";
1583  return;
1584  }
1585 
1586  if (in_global)
1587  {
1588  global_block->remove(short_name);
1589  global_block->setDoubleIndexParam<T>(short_name).resize(outer_vector_size);
1590  for (const auto j : make_range(outer_vector_size))
1591  {
1592  global_block->setDoubleIndexParam<T>(short_name)[j].resize(value[j].size());
1593  for (const auto i : index_range(value[j]))
1594  global_block->setDoubleIndexParam<T>(short_name)[j][i] = value[j][i];
1595  }
1596  }
1597 }
1598 
1599 template <typename T>
1600 void
1602  const std::string & full_name,
1603  const std::string & short_name,
1604  InputParameters::Parameter<std::vector<std::vector<std::vector<T>>>> * param,
1605  bool in_global,
1606  GlobalParamsAction * global_block)
1607 {
1608  // Get the full string assigned to the variable full_name
1609  const std::string buffer_raw = root()->param<std::string>(full_name);
1610  // In case the parameter is empty
1611  if (buffer_raw.find_first_not_of(' ', 0) == std::string::npos)
1612  return;
1613 
1614  // Add a space between neighboring delim's, before the first delim if nothing is ahead of it, and
1615  // after the last delim if nothing is behind it.
1616  std::string buffer;
1617  buffer.push_back(buffer_raw[0]);
1618  if (buffer[0] == '|' || buffer[0] == ';')
1619  buffer = ' ' + buffer;
1620  for (std::string::size_type i = 1; i < buffer_raw.size(); i++)
1621  {
1622  if ((buffer_raw[i - 1] == '|' || buffer_raw[i - 1] == ';') &&
1623  (buffer_raw[i] == '|' || buffer_raw[i] == ';'))
1624  buffer.push_back(' ');
1625  buffer.push_back(buffer_raw[i]);
1626  }
1627  if (buffer.back() == '|' || buffer.back() == ';')
1628  buffer.push_back(' ');
1629 
1630  // split vector at delim | to get a series of 2D subvectors
1631  std::vector<std::string> first_tokenized_vector;
1632  std::vector<std::vector<std::string>> second_tokenized_vector;
1633  MooseUtils::tokenize(buffer, first_tokenized_vector, 1, "|");
1634  param->set().resize(first_tokenized_vector.size());
1635  second_tokenized_vector.resize(first_tokenized_vector.size());
1636  for (unsigned j = 0; j < first_tokenized_vector.size(); ++j)
1637  {
1638  // Identify empty subvector first
1639  if (first_tokenized_vector[j].find_first_not_of(' ', 0) == std::string::npos)
1640  {
1641  param->set()[j].resize(0);
1642  continue;
1643  }
1644  // split each 2D subvector at delim ; to get 1D sub-subvectors
1645  // NOTE: the 1D sub-subvectors are _not_ of type T yet
1646  MooseUtils::tokenize(first_tokenized_vector[j], second_tokenized_vector[j], 1, ";");
1647  param->set()[j].resize(second_tokenized_vector[j].size());
1648  for (unsigned k = 0; k < second_tokenized_vector[j].size(); ++k)
1649  if (!MooseUtils::tokenizeAndConvert<T>(second_tokenized_vector[j][k], param->set()[j][k]))
1650  {
1651  _errmsg +=
1652  hit::errormsg(root()->find(full_name), "invalid format for parameter ", full_name) +
1653  "\n";
1654  return;
1655  }
1656  }
1657 
1658  if (in_global)
1659  {
1660  global_block->remove(short_name);
1661  global_block->setTripleIndexParam<T>(short_name).resize(first_tokenized_vector.size());
1662  for (unsigned j = 0; j < first_tokenized_vector.size(); ++j)
1663  {
1664  global_block->setTripleIndexParam<T>(short_name)[j].resize(second_tokenized_vector[j].size());
1665  for (unsigned k = 0; k < second_tokenized_vector[j].size(); ++k)
1666  {
1667  global_block->setTripleIndexParam<T>(short_name)[j][k].resize(param->get()[j][k].size());
1668  for (unsigned int i = 0; i < param->get()[j][k].size(); ++i)
1669  global_block->setTripleIndexParam<T>(short_name)[j][k][i] = param->get()[j][k][i];
1670  }
1671  }
1672  }
1673 }
1674 
1675 template <typename T>
1676 void
1677 Builder::setScalarComponentParameter(const std::string & full_name,
1678  const std::string & short_name,
1679  InputParameters::Parameter<T> * param,
1680  bool in_global,
1681  GlobalParamsAction * global_block)
1682 {
1683  std::vector<double> vec;
1684  try
1685  {
1686  vec = root()->param<std::vector<double>>(full_name);
1687  }
1688  catch (hit::Error & err)
1689  {
1690  _errmsg += hit::errormsg(root()->find(full_name), err.what()) + "\n";
1691  return;
1692  }
1693 
1694  if (vec.size() != LIBMESH_DIM)
1695  {
1696  _errmsg += hit::errormsg(root()->find(full_name),
1697  "wrong number of values in scalar component parameter ",
1698  full_name,
1699  ": ",
1700  short_name,
1701  " was given ",
1702  vec.size(),
1703  " components but should have ",
1704  LIBMESH_DIM) +
1705  "\n";
1706  return;
1707  }
1708 
1709  T value;
1710  for (unsigned int i = 0; i < vec.size(); ++i)
1711  value(i) = Real(vec[i]);
1712 
1713  param->set() = value;
1714  if (in_global)
1715  {
1716  global_block->remove(short_name);
1717  global_block->setScalarParam<T>(short_name) = value;
1718  }
1719 }
1720 
1721 template <typename T>
1722 void
1723 Builder::setVectorComponentParameter(const std::string & full_name,
1724  const std::string & short_name,
1725  InputParameters::Parameter<std::vector<T>> * param,
1726  bool in_global,
1727  GlobalParamsAction * global_block)
1728 {
1729  std::vector<double> vec;
1730  try
1731  {
1732  vec = root()->param<std::vector<double>>(full_name);
1733  }
1734  catch (hit::Error & err)
1735  {
1736  _errmsg += hit::errormsg(root()->find(full_name), err.what()) + "\n";
1737  return;
1738  }
1739 
1740  if (vec.size() % LIBMESH_DIM)
1741  {
1742  _errmsg += hit::errormsg(root()->find(full_name),
1743  "wrong number of values in vector component parameter ",
1744  full_name,
1745  ": size ",
1746  vec.size(),
1747  " is not a multiple of ",
1748  LIBMESH_DIM) +
1749  "\n";
1750  return;
1751  }
1752 
1753  std::vector<T> values;
1754  for (unsigned int i = 0; i < vec.size() / LIBMESH_DIM; ++i)
1755  {
1756  T value;
1757  for (int j = 0; j < LIBMESH_DIM; ++j)
1758  value(j) = Real(vec[i * LIBMESH_DIM + j]);
1759  values.push_back(value);
1760  }
1761 
1762  param->set() = values;
1763 
1764  if (in_global)
1765  {
1766  global_block->remove(short_name);
1767  global_block->setVectorParam<T>(short_name).resize(vec.size(), values[0]);
1768  for (unsigned int i = 0; i < vec.size() / LIBMESH_DIM; ++i)
1769  global_block->setVectorParam<T>(short_name)[i] = values[0];
1770  }
1771 }
1772 
1773 template <typename T>
1774 void
1776  const std::string & full_name,
1777  const std::string & short_name,
1778  InputParameters::Parameter<std::vector<std::vector<T>>> * param,
1779  bool in_global,
1780  GlobalParamsAction * global_block)
1781 {
1782  // Get the full string assigned to the variable full_name
1783  std::string buffer = root()->param<std::string>(full_name);
1784 
1785  // split vector at delim ;
1786  // NOTE: the substrings are _not_ of type T yet
1787  std::vector<std::string> first_tokenized_vector;
1788  MooseUtils::tokenize(buffer, first_tokenized_vector, 1, ";");
1789  param->set().resize(first_tokenized_vector.size());
1790 
1791  // get a vector<vector<double>> first
1792  std::vector<std::vector<double>> vecvec(first_tokenized_vector.size());
1793  for (unsigned j = 0; j < vecvec.size(); ++j)
1794  if (!MooseUtils::tokenizeAndConvert<double>(first_tokenized_vector[j], vecvec[j]))
1795  {
1796  _errmsg +=
1797  hit::errormsg(root()->find(full_name), "invalid format for parameter ", full_name) + "\n";
1798  return;
1799  }
1800 
1801  for (const auto & vec : vecvec)
1802  if (vec.size() % LIBMESH_DIM)
1803  {
1804  _errmsg +=
1805  hit::errormsg(root()->find(full_name),
1806  "wrong number of values in double-indexed vector component parameter ",
1807  full_name,
1808  ": size of subcomponent ",
1809  vec.size(),
1810  " is not a multiple of ",
1811  LIBMESH_DIM) +
1812  "\n";
1813  return;
1814  }
1815 
1816  // convert vector<vector<double>> to vector<vector<T>>
1817  std::vector<std::vector<T>> values(vecvec.size());
1818  for (unsigned int id_vec = 0; id_vec < vecvec.size(); ++id_vec)
1819  for (unsigned int i = 0; i < vecvec[id_vec].size() / LIBMESH_DIM; ++i)
1820  {
1821  T value;
1822  for (int j = 0; j < LIBMESH_DIM; ++j)
1823  value(j) = Real(vecvec[id_vec][i * LIBMESH_DIM + j]);
1824  values[id_vec].push_back(value);
1825  }
1826 
1827  param->set() = values;
1828 
1829  if (in_global)
1830  {
1831  global_block->remove(short_name);
1832  global_block->setDoubleIndexParam<T>(short_name).resize(vecvec.size());
1833  for (unsigned j = 0; j < vecvec.size(); ++j)
1834  {
1835  global_block->setDoubleIndexParam<T>(short_name)[j].resize(param->get()[j].size() /
1836  LIBMESH_DIM);
1837  for (unsigned int i = 0; i < param->get()[j].size() / LIBMESH_DIM; ++i)
1838  global_block->setDoubleIndexParam<T>(short_name)[j][i] = values[j][i];
1839  }
1840  }
1841 }
1842 
1843 template <>
1844 void
1845 Builder::setScalarParameter<RealVectorValue, RealVectorValue>(
1846  const std::string & full_name,
1847  const std::string & short_name,
1848  InputParameters::Parameter<RealVectorValue> * param,
1849  bool in_global,
1850  GlobalParamsAction * global_block)
1851 {
1852  setScalarComponentParameter(full_name, short_name, param, in_global, global_block);
1853 }
1854 
1855 template <>
1856 void
1857 Builder::setScalarParameter<Point, Point>(const std::string & full_name,
1858  const std::string & short_name,
1859  InputParameters::Parameter<Point> * param,
1860  bool in_global,
1861  GlobalParamsAction * global_block)
1862 {
1863  setScalarComponentParameter(full_name, short_name, param, in_global, global_block);
1864 }
1865 
1866 template <>
1867 void
1868 Builder::setScalarParameter<RealEigenVector, RealEigenVector>(
1869  const std::string & full_name,
1870  const std::string & short_name,
1871  InputParameters::Parameter<RealEigenVector> * param,
1872  bool in_global,
1873  GlobalParamsAction * global_block)
1874 {
1875  std::vector<double> vec;
1876  try
1877  {
1878  vec = root()->param<std::vector<double>>(full_name);
1879  }
1880  catch (hit::Error & err)
1881  {
1882  _errmsg += hit::errormsg(root()->find(full_name), err.what()) + "\n";
1883  return;
1884  }
1885 
1886  RealEigenVector value(vec.size());
1887  for (unsigned int i = 0; i < vec.size(); ++i)
1888  value(i) = Real(vec[i]);
1889 
1890  param->set() = value;
1891  if (in_global)
1892  {
1893  global_block->remove(short_name);
1894  global_block->setScalarParam<RealEigenVector>(short_name) = value;
1895  }
1896 }
1897 
1898 template <>
1899 void
1900 Builder::setScalarParameter<RealEigenMatrix, RealEigenMatrix>(
1901  const std::string & full_name,
1902  const std::string & short_name,
1903  InputParameters::Parameter<RealEigenMatrix> * param,
1904  bool in_global,
1905  GlobalParamsAction * global_block)
1906 {
1907  // Get the full string assigned to the variable full_name
1908  std::string buffer = root()->param<std::string>(full_name);
1909 
1910  // split vector at delim ;
1911  // NOTE: the substrings are _not_ of type T yet
1912  std::vector<std::string> first_tokenized_vector;
1913  MooseUtils::tokenize(buffer, first_tokenized_vector, 1, ";");
1914 
1915  std::vector<std::vector<Real>> values(first_tokenized_vector.size());
1916 
1917  for (unsigned j = 0; j < first_tokenized_vector.size(); ++j)
1918  {
1919  if (!MooseUtils::tokenizeAndConvert<Real>(first_tokenized_vector[j], values[j]))
1920  {
1921  _errmsg +=
1922  hit::errormsg(root()->find(full_name), "invalid format for parameter ", full_name) + "\n";
1923  return;
1924  }
1925  if (j != 0 && values[j].size() != values[0].size())
1926  {
1927  _errmsg +=
1928  hit::errormsg(root()->find(full_name), "invalid format for parameter ", full_name) + "\n";
1929  return;
1930  }
1931  }
1932 
1933  RealEigenMatrix value(values.size(), values[0].size());
1934  for (unsigned int i = 0; i < values.size(); ++i)
1935  for (unsigned int j = 0; j < values[i].size(); ++j)
1936  value(i, j) = values[i][j];
1937 
1938  param->set() = value;
1939  if (in_global)
1940  {
1941  global_block->remove(short_name);
1942  global_block->setScalarParam<RealEigenMatrix>(short_name) = value;
1943  }
1944 }
1945 
1946 template <>
1947 void
1948 Builder::setScalarParameter<MooseEnum, MooseEnum>(const std::string & full_name,
1949  const std::string & short_name,
1950  InputParameters::Parameter<MooseEnum> * param,
1951  bool in_global,
1952  GlobalParamsAction * global_block)
1953 {
1954  MooseEnum current_param = param->get();
1955 
1956  std::string value = root()->param<std::string>(full_name);
1957 
1958  param->set() = value;
1959  if (in_global)
1960  {
1961  global_block->remove(short_name);
1962  global_block->setScalarParam<MooseEnum>(short_name) = current_param;
1963  }
1964 }
1965 
1966 template <>
1967 void
1968 Builder::setScalarParameter<MultiMooseEnum, MultiMooseEnum>(
1969  const std::string & full_name,
1970  const std::string & short_name,
1971  InputParameters::Parameter<MultiMooseEnum> * param,
1972  bool in_global,
1973  GlobalParamsAction * global_block)
1974 {
1975  MultiMooseEnum current_param = param->get();
1976 
1977  auto vec = root()->param<std::vector<std::string>>(full_name);
1978 
1979  std::string raw_values;
1980  for (unsigned int i = 0; i < vec.size(); ++i)
1981  raw_values += ' ' + vec[i];
1982 
1983  param->set() = raw_values;
1984 
1985  if (in_global)
1986  {
1987  global_block->remove(short_name);
1988  global_block->setScalarParam<MultiMooseEnum>(short_name) = current_param;
1989  }
1990 }
1991 
1992 template <>
1993 void
1994 Builder::setScalarParameter<ExecFlagEnum, ExecFlagEnum>(
1995  const std::string & full_name,
1996  const std::string & short_name,
1997  InputParameters::Parameter<ExecFlagEnum> * param,
1998  bool in_global,
1999  GlobalParamsAction * global_block)
2000 {
2001  ExecFlagEnum current_param = param->get();
2002  auto vec = root()->param<std::vector<std::string>>(full_name);
2003 
2004  std::string raw_values;
2005  for (unsigned int i = 0; i < vec.size(); ++i)
2006  raw_values += ' ' + vec[i];
2007 
2008  param->set() = raw_values;
2009 
2010  if (in_global)
2011  {
2012  global_block->remove(short_name);
2013  global_block->setScalarParam<ExecFlagEnum>(short_name) = current_param;
2014  }
2015 }
2016 
2017 template <>
2018 void
2019 Builder::setScalarParameter<RealTensorValue, RealTensorValue>(
2020  const std::string & full_name,
2021  const std::string & short_name,
2022  InputParameters::Parameter<RealTensorValue> * param,
2023  bool in_global,
2024  GlobalParamsAction * global_block)
2025 {
2026  auto vec = root()->param<std::vector<double>>(full_name);
2027  if (vec.size() != LIBMESH_DIM * LIBMESH_DIM)
2028  {
2029  _errmsg += hit::errormsg(root()->find(full_name),
2030  "invalid RealTensorValue parameter ",
2031  full_name,
2032  ": size is ",
2033  vec.size(),
2034  " but should be ",
2035  LIBMESH_DIM * LIBMESH_DIM) +
2036  "\n";
2037  return;
2038  }
2039 
2041  for (int i = 0; i < LIBMESH_DIM; ++i)
2042  for (int j = 0; j < LIBMESH_DIM; ++j)
2043  value(i, j) = Real(vec[i * LIBMESH_DIM + j]);
2044 
2045  param->set() = value;
2046  if (in_global)
2047  {
2048  global_block->remove(short_name);
2049  global_block->setScalarParam<RealTensorValue>(short_name) = value;
2050  }
2051 }
2052 
2053 // Specialization for coupling a Real value where a postprocessor would be needed in MOOSE
2054 template <>
2055 void
2056 Builder::setScalarParameter<PostprocessorName, PostprocessorName>(
2057  const std::string & full_name,
2058  const std::string & short_name,
2059  InputParameters::Parameter<PostprocessorName> * param,
2060  bool in_global,
2061  GlobalParamsAction * global_block)
2062 {
2063  PostprocessorName pps_name = root()->param<std::string>(full_name);
2064  param->set() = pps_name;
2065 
2066  if (in_global)
2067  {
2068  global_block->remove(short_name);
2069  global_block->setScalarParam<PostprocessorName>(short_name) = pps_name;
2070  }
2071 }
2072 
2073 template <>
2074 void
2075 Builder::setScalarParameter<ReporterName, std::string>(
2076  const std::string & full_name,
2077  const std::string & /*short_name*/,
2078  InputParameters::Parameter<ReporterName> * param,
2079  bool /*in_global*/,
2080  GlobalParamsAction * /*global_block*/)
2081 {
2082  std::vector<std::string> names =
2083  MooseUtils::rsplit(root()->param<std::string>(full_name), "/", 2);
2084  if (names.size() != 2)
2085  _errmsg += hit::errormsg(root()->find(full_name),
2086  "The supplied name ReporterName '",
2087  full_name,
2088  "' must contain the '/' delimiter.");
2089  else
2090  param->set() = ReporterName(names[0], names[1]);
2091 }
2092 
2093 template <>
2094 void
2095 Builder::setVectorParameter<RealVectorValue, RealVectorValue>(
2096  const std::string & full_name,
2097  const std::string & short_name,
2098  InputParameters::Parameter<std::vector<RealVectorValue>> * param,
2099  bool in_global,
2100  GlobalParamsAction * global_block)
2101 {
2102  setVectorComponentParameter(full_name, short_name, param, in_global, global_block);
2103 }
2104 
2105 template <>
2106 void
2107 Builder::setVectorParameter<Point, Point>(const std::string & full_name,
2108  const std::string & short_name,
2109  InputParameters::Parameter<std::vector<Point>> * param,
2110  bool in_global,
2111  GlobalParamsAction * global_block)
2112 {
2113  setVectorComponentParameter(full_name, short_name, param, in_global, global_block);
2114 }
2115 
2116 template <>
2117 void
2118 Builder::setVectorParameter<MooseEnum, MooseEnum>(
2119  const std::string & full_name,
2120  const std::string & short_name,
2121  InputParameters::Parameter<std::vector<MooseEnum>> * param,
2122  bool in_global,
2123  GlobalParamsAction * global_block)
2124 {
2125  std::vector<MooseEnum> enum_values = param->get();
2126  std::vector<std::string> values(enum_values.size());
2127  for (unsigned int i = 0; i < values.size(); ++i)
2128  values[i] = static_cast<std::string>(enum_values[i]);
2129 
2134  std::vector<std::string> vec;
2135  if (root()->find(full_name))
2136  {
2137  vec = root()->param<std::vector<std::string>>(full_name);
2138  param->set().resize(vec.size(), enum_values[0]);
2139  }
2140 
2141  for (unsigned int i = 0; i < vec.size(); ++i)
2142  param->set()[i] = vec[i];
2143 
2144  if (in_global)
2145  {
2146  global_block->remove(short_name);
2147  global_block->setVectorParam<MooseEnum>(short_name).resize(vec.size(), enum_values[0]);
2148  for (unsigned int i = 0; i < vec.size(); ++i)
2149  global_block->setVectorParam<MooseEnum>(short_name)[i] = values[0];
2150  }
2151 }
2152 
2153 template <>
2154 void
2155 Builder::setVectorParameter<MultiMooseEnum, MultiMooseEnum>(
2156  const std::string & full_name,
2157  const std::string & short_name,
2158  InputParameters::Parameter<std::vector<MultiMooseEnum>> * param,
2159  bool in_global,
2160  GlobalParamsAction * global_block)
2161 {
2162  const std::vector<MultiMooseEnum> & enum_values = param->get();
2163 
2164  // Get the full string assigned to the variable full_name
2165  std::string buffer = root()->param<std::string>(full_name);
2166 
2167  std::vector<std::string> first_tokenized_vector = MooseUtils::split(buffer, ";");
2168  for (const auto & i : first_tokenized_vector)
2169  if (MooseUtils::trim(i) == "")
2170  mooseError("In " + full_name + ", one entry in the vector is empty. This is not allowed.");
2171 
2172  param->set().resize(first_tokenized_vector.size(), enum_values[0]);
2173 
2174  std::vector<std::vector<std::string>> vecvec(first_tokenized_vector.size());
2175  for (const auto i : index_range(vecvec))
2176  {
2177  MooseUtils::tokenize<std::string>(first_tokenized_vector[i], vecvec[i], 1, " ");
2178  param->set()[i] = vecvec[i];
2179  }
2180 
2181  if (in_global)
2182  {
2183  global_block->remove(short_name);
2184  global_block->setVectorParam<MultiMooseEnum>(short_name).resize(vecvec.size(), enum_values[0]);
2185  for (unsigned int i = 0; i < vecvec.size(); ++i)
2186  global_block->setVectorParam<MultiMooseEnum>(short_name)[i] = vecvec[i];
2187  }
2188 }
2189 
2190 template <>
2191 void
2192 Builder::setVectorParameter<PostprocessorName, PostprocessorName>(
2193  const std::string & full_name,
2194  const std::string & short_name,
2195  InputParameters::Parameter<std::vector<PostprocessorName>> * param,
2196  bool in_global,
2197  GlobalParamsAction * global_block)
2198 {
2199  std::vector<std::string> pps_names = root()->param<std::vector<std::string>>(full_name);
2200  unsigned int n = pps_names.size();
2201  param->set().resize(n);
2202 
2203  for (unsigned int j = 0; j < n; ++j)
2204  param->set()[j] = pps_names[j];
2205 
2206  if (in_global)
2207  {
2208  global_block->remove(short_name);
2209  global_block->setVectorParam<PostprocessorName>(short_name).resize(n, "");
2210  for (unsigned int j = 0; j < n; ++j)
2211  global_block->setVectorParam<PostprocessorName>(short_name)[j] = pps_names[j];
2212  }
2213 }
2214 
2219 template <>
2220 void
2221 Builder::setVectorParameter<VariableName, VariableName>(
2222  const std::string & full_name,
2223  const std::string & short_name,
2224  InputParameters::Parameter<std::vector<VariableName>> * param,
2225  bool /*in_global*/,
2226  GlobalParamsAction * /*global_block*/)
2227 {
2228  auto vec = root()->param<std::vector<std::string>>(full_name);
2229  auto strval = root()->param<std::string>(full_name);
2230  std::vector<VariableName> var_names(vec.size());
2231 
2232  bool has_var_names = false;
2233  for (unsigned int i = 0; i < vec.size(); ++i)
2234  {
2235  VariableName var_name = vec[i];
2236 
2237  Real real_value;
2238  std::istringstream ss(var_name);
2239 
2240  // If we are able to convert this value into a Real, then set a default coupled value
2241  // NOTE: parameter must be either all default or no defaults
2242  if (ss >> real_value && ss.eof())
2243  _current_params->defaultCoupledValue(short_name, real_value, i);
2244  else
2245  {
2246  var_names[i] = var_name;
2247  has_var_names = true;
2248  }
2249  }
2250 
2251  if (has_var_names)
2252  {
2253  param->set().resize(vec.size());
2254 
2255  for (unsigned int i = 0; i < vec.size(); ++i)
2256  if (var_names[i] == "")
2257  {
2258  _errmsg += hit::errormsg(root()->find(full_name),
2259  "invalid value for ",
2260  full_name,
2261  ":\n"
2262  " MOOSE does not currently support a coupled vector where "
2263  "some parameters are ",
2264  "reals and others are variables") +
2265  "\n";
2266  return;
2267  }
2268  else
2269  param->set()[i] = var_names[i];
2270  }
2271 }
2272 
2273 template <>
2274 void
2275 Builder::setVectorParameter<ReporterName, std::string>(
2276  const std::string & full_name,
2277  const std::string & /*short_name*/,
2278  InputParameters::Parameter<std::vector<ReporterName>> * param,
2279  bool /*in_global*/,
2280  GlobalParamsAction * /*global_block*/)
2281 {
2282  auto rnames = root()->param<std::vector<std::string>>(full_name);
2283  param->set().resize(rnames.size());
2284 
2285  for (unsigned int i = 0; i < rnames.size(); ++i)
2286  {
2287  std::vector<std::string> names = MooseUtils::rsplit(rnames[i], "/", 2);
2288  if (names.size() != 2)
2289  _errmsg += hit::errormsg(root()->find(full_name),
2290  "The supplied name ReporterName '",
2291  rnames[i],
2292  "' must contain the '/' delimiter.");
2293  else
2294  param->set()[i] = ReporterName(names[0], names[1]);
2295  }
2296 }
2297 
2298 template <>
2299 void
2300 Builder::setVectorParameter<CLIArgString, std::string>(
2301  const std::string & full_name,
2302  const std::string & /*short_name*/,
2303  InputParameters::Parameter<std::vector<CLIArgString>> * param,
2304  bool /*in_global*/,
2305  GlobalParamsAction * /*global_block*/)
2306 {
2307  // Parsed as a vector of string, the vectors parameters are being cut
2308  auto rnames = root()->param<std::vector<std::string>>(full_name);
2309  param->set().resize(rnames.size()); // slightly oversized if vectors have been split
2310 
2311  // Skip empty parameter
2312  if (rnames.empty())
2313  return;
2314 
2315  // Re-assemble vector parameters
2316  unsigned int i_param = 0;
2317  bool vector_param_detected = false;
2318  for (unsigned int i = 0; i < rnames.size(); ++i)
2319  {
2320  // Look for a quote, both types
2321  std::vector<std::string> double_split =
2323  std::vector<std::string> single_split =
2325  if (double_split.size() + single_split.size() >= 3)
2326  // Either entering or exiting a vector parameter (>3 is entering another vector)
2327  // Even and >2 number of quotes means both finished and started another vector parameter
2328  if ((double_split.size() + single_split.size()) % 2 == 1)
2329  vector_param_detected = !vector_param_detected;
2330 
2331  // We're building a vector parameters, just append the text, rebuild the spaces
2332  if (vector_param_detected)
2333  param->set()[i_param] += rnames[i] + ' ';
2334  else
2335  {
2336  param->set()[i_param] += rnames[i];
2337  i_param++;
2338  }
2339  }
2340  // Use actual size after re-forming vector parameters
2341  param->set().resize(i_param);
2342 }
2343 
2344 template <>
2345 void
2346 Builder::setDoubleIndexParameter<Point>(
2347  const std::string & full_name,
2348  const std::string & short_name,
2349  InputParameters::Parameter<std::vector<std::vector<Point>>> * param,
2350  bool in_global,
2351  GlobalParamsAction * global_block)
2352 {
2353  setVectorVectorComponentParameter(full_name, short_name, param, in_global, global_block);
2354 }
2355 
2356 } // end of namespace Moose
std::string name(const ElemQuality q)
OStreamProxy err
hit::Node * root()
Definition: Builder.C:321
void build()
Parse an input file (or text string if provided) consisting of hit syntax and setup objects in the MO...
Definition: Builder.C:328
ActionFactory & _action_factory
The Factory that builds actions.
Definition: Builder.h:230
MooseApp & _app
The MooseApp this Parser is part of.
Definition: Builder.h:224
const std::multimap< std::string, std::string > & getAssociatedTypes() const
Get a multimap of registered associations of syntax with type.
Definition: Syntax.C:368
void walk(const std::string &fullpath, const std::string &nodename, hit::Node *n) override
Definition: Builder.C:179
std::pair< std::multimap< std::string, ActionInfo >::const_iterator, std::multimap< std::string, ActionInfo >::const_iterator > getActions(const std::string &syntax) const
Returns a pair of multimap iterators to all the ActionInfo objects associated with a given piece of s...
Definition: Syntax.C:328
std::unordered_set< std::string > _deprec_param_tracker
Tracks whether a deprecated param has had its warning message printed already.
Definition: Builder.h:252
void walkRaw(std::string fullpath, std::string nodepath, hit::Node *n)
Definition: Builder.C:206
A MultiMooseEnum object to hold "execute_on" flags.
Definition: ExecFlagEnum.h:21
virtual std::string type() const=0
void tokenize(const std::string &str, std::vector< T > &elements, unsigned int min_len=1, const std::string &delims="/")
This function will split the passed in string on a set of delimiters appending the substrings to the ...
Definition: MooseUtils.h:812
InputParameters & getComponentParams()
Return the parameters of the component.
void setTripleIndexParameter(const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< std::vector< std::vector< T >>>> *param, bool in_global, GlobalParamsAction *global_block)
Template method for setting any triple indexed type parameter read from the input file or command lin...
Definition: Builder.C:1601
std::list< Action * >::iterator ActionIterator
alias to hide implementation details
const std::multimap< std::string, ActionInfo > & getAssociatedActions() const
Return all Syntax to Action associations.
Definition: Syntax.C:374
std::vector< std::string > errors
Definition: Parser.h:67
void buildFullTree(const std::string &search_string)
Use MOOSE Factories to construct a full parse tree for documentation or echoing input.
Definition: Builder.C:640
MPI_Info info
void mooseObjectSyntaxVisibility(bool visibility)
Mutators for controlling whether or not the outermost level of syntax will be collapsed when printed...
InputParameters getValidParams(const std::string &name)
Definition: ActionFactory.C:92
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
std::shared_ptr< CommandLine > commandLine() const
Get the command line.
Definition: MooseApp.h:451
std::vector< std::string > _secs_need_first
Definition: Builder.h:221
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
void setVectorVectorComponentParameter(const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< std::vector< T >>> *param, bool in_global, GlobalParamsAction *global_block)
Template method for setting vector of several multivalue "scalar" type parameter read from the input ...
Definition: Builder.C:1775
std::string associatedClassName(const std::string &name) const
Get the associated class name for an object name.
Definition: Factory.C:272
std::pair< std::multimap< std::string, std::string >::const_iterator, std::multimap< std::string, std::string >::const_iterator > getActionsByTask(const std::string &task) const
Returns begin and end iterators in a multimap from tasks to actions names.
T * get(const std::unique_ptr< T > &u)
The MooseUtils::get() specializations are used to support making forwards-compatible code changes fro...
Definition: MooseUtils.h:1191
std::set< std::string > getTasksByAction(const std::string &action) const
const std::vector< std::string > & getBuildableTypes() const
Returns the list of buildable types as a std::vector<std::string>
InputParameters * _current_params
The current parameter object for which parameters are being extracted.
Definition: Builder.h:246
FileLineInfo getLineInfo(const std::string &syntax, const std::string &action, const std::string &task) const
Gets the file and line where the syntax/action/task combo was registered.
Definition: Syntax.C:380
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
void setScalarComponentParameter(const std::string &full_name, const std::string &short_name, InputParameters::Parameter< T > *param, bool in_global, GlobalParamsAction *global_block)
Template method for setting any multivalue "scalar" type parameter read from the input file or comman...
Definition: Builder.C:1677
Builder & _builder
Definition: Builder.h:50
static InputParameters validParams()
Parameters that are processed directly by the Parser and are valid anywhere in the input...
Definition: Builder.C:141
Base class for MOOSE-based applications.
Definition: MooseApp.h:85
void setMapParameter(const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::map< KeyType, MappedType >> *param, bool in_global, GlobalParamsAction *global_block)
Template method for setting any map type parameter read from the input file or command line...
Definition: Builder.C:1453
unsigned int size() const
Return the number of active items in the MultiMooseEnum.
Storage for action instances.
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
void addActionBlock(std::shared_ptr< Action > blk)
This method add an Action instance to the warehouse.
FileLineInfo getLineInfo(const std::string &name, const std::string &task) const
Gets file and line information where an action was registered.
std::unique_ptr< T_DEST, T_DELETER > dynamic_pointer_cast(std::unique_ptr< T_SRC, T_DELETER > &src)
These are reworked from https://stackoverflow.com/a/11003103.
bool toBool(const std::string &, T &)
Definition: Builder.C:1327
Action for creating component actions.
std::unique_ptr< SyntaxTree > _syntax_formatter
Object for holding the syntax parse tree.
Definition: Builder.h:237
std::vector< T > & setVectorParam(const std::string &name)
Holds the syntax in a Json::Value tree.
void extractParams(const std::string &prefix, InputParameters &p)
This function attempts to extract values from the input file based on the contents of the passed para...
Definition: Builder.C:887
std::vector< std::vector< T > > & setDoubleIndexParam(const std::string &name)
std::string _action
Definition: Syntax.h:26
FileLineInfo getLineInfo(const std::string &name) const
Gets file and line information where an object was initially registered.
Definition: Factory.C:260
std::shared_ptr< Action > create(const std::string &action, const std::string &action_name, InputParameters &parameters)
Definition: ActionFactory.C:39
InputParameters emptyInputParameters()
std::vector< std::string > getSyntaxByAction(const std::string &action, const std::string &task="")
Retrieve the syntax associated with the passed in action type string.
Definition: Syntax.C:211
auto max(const L &left, const R &right)
std::vector< std::string > split(const std::string &str, const std::string &delimiter, std::size_t max_count=std::numeric_limits< std::size_t >::max())
Python like split functions for strings.
Definition: MooseUtils.C:1152
std::vector< std::string > errors
Definition: Builder.h:46
void setScalarValueTypeParameter(const std::string &full_name, const std::string &short_name, InputParameters::Parameter< T > *param, bool in_global, GlobalParamsAction *global_block)
Definition: Builder.C:1401
const std::shared_ptr< Parser > _parser
The front parser.
Definition: Builder.h:234
bool isDeprecatedSyntax(const std::string &syntax) const
Returns a Boolean indicating whether the syntax has been deprecated through a call to deprecateAction...
Definition: Syntax.C:205
std::vector< std::string > rsplit(const std::string &str, const std::string &delimiter, std::size_t max_count=std::numeric_limits< std::size_t >::max())
Definition: MooseUtils.C:1172
TensorValue< Real > RealTensorValue
static InputParameters validParams()
Definition: Action.C:24
InputParameters & getObjectParams()
Retrieve the parameters of the object to be created by this action.
std::string _warnmsg
Definition: Builder.h:256
std::set< std::string > _extracted_vars
The set of all variables extracted from the input file.
Definition: Builder.h:240
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
void mooseUnused(Args &&... args)
Warning message used to notify the users of unused parts of their input files Really used internally ...
Definition: MooseError.h:345
boundary_id_type BoundaryID
constexpr auto merge(std::index_sequence< first... >, std::index_sequence< second... >)
Merge two index sequences into one.
void initSyntaxFormatter(SyntaxFormatterType type, bool dump_mode)
Creates a syntax formatter for printing.
Definition: Builder.C:463
static InputParameters validParams()
Definition: EmptyAction.C:19
T & setScalarParam(const std::string &name)
An inteface for the _console for outputting to the Console object.
std::vector< std::vector< std::vector< T > > > & setTripleIndexParam(const std::string &name)
std::string trim(const std::string &str, const std::string &white_space=" \\\)
Standard scripting language trim function.
Definition: MooseUtils.C:221
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:33
void buildJsonSyntaxTree(JsonSyntaxTree &tree) const
Use MOOSE Factories to construct a parameter tree for documentation or echoing input.
Definition: Builder.C:480
void mooseDeprecated(Args &&... args)
Emit a deprecated code/feature message with the given stringified, concatenated args.
Definition: MooseError.h:353
void errorCheck(const libMesh::Parallel::Communicator &comm, bool warn_unused, bool err_unused)
Definition: Builder.C:419
Eigen::Matrix< Real, Eigen::Dynamic, Eigen::Dynamic > RealEigenMatrix
Definition: MooseTypes.h:145
const auto & registeredObjects() const
Returns a reference to the map from names to RegistryEntryBase pointers.
Definition: Factory.h:147
std::string getPrimaryFileName(bool stripLeadingPath=true) const
Return the primary (first) filename that was parsed.
Definition: Builder.C:199
std::string demangle(const char *name)
std::unique_ptr< hit::Node > _cli_root
Definition: Builder.h:217
void setScalarParameter(const std::string &full_name, const std::string &short_name, InputParameters::Parameter< T > *param, bool in_global, GlobalParamsAction *global_block)
Helper functions for setting parameters of arbitrary types - bodies are in the .C file since they are...
Definition: Builder.C:1341
void rangeCheck(const std::string &full_name, const std::string &short_name, InputParameters::Parameter< T > *param, std::ostream &oss=Moose::out)
Runs a range on the supplied parameter if it exists and throws an error if that check fails...
std::string isAssociated(const std::string &real_id, bool *is_parent, const std::map< std::string, std::set< std::string >> &alt_map={}) const
Method for determining whether a piece of syntax is associated with an Action an optional syntax map ...
Definition: Syntax.C:251
bool toBool< bool >(const std::string &s, bool &val)
Definition: Builder.C:1334
std::string getTaskName(const std::string &action)
bool have_parameter(std::string_view name) const
A wrapper around the Parameters base class method.
std::string _task
Definition: Syntax.h:27
std::string baseName(const std::string &name)
Function for string the information before the final / in a parser block.
Definition: MooseUtils.C:624
unsigned int get(unsigned int i) const
Indexing operator Operator to retrieve the id of an item from the MultiMooseEnum. ...
void setDoubleIndexParameter(const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< std::vector< T >>> *param, bool in_global, GlobalParamsAction *global_block)
Template method for setting any double indexed type parameter read from the input file or command lin...
Definition: Builder.C:1554
std::ostringstream * _current_error_stream
The current stream object used for capturing errors during extraction.
Definition: Builder.h:249
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
std::string _errmsg
Definition: Builder.h:255
Syntax & _syntax
Reference to an object that defines input file syntax.
Definition: Builder.h:232
std::set< std::string > _used
Definition: Builder.h:49
void setVectorParameter(const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< T >> *param, bool in_global, GlobalParamsAction *global_block)
Template method for setting any vector type parameter read from the input file or command line...
Definition: Builder.C:1418
IntRange< T > make_range(T beg, T end)
int levenshteinDist(const std::string &s1, const std::string &s2)
Computes and returns the Levenshtein distance between strings s1 and s2.
Definition: MooseUtils.C:172
bool verifyMooseObjectTask(const std::string &base, const std::string &task) const
Returns a Boolean indicating whether a task is associated with on of the MOOSE pluggable systems (BAS...
Definition: Syntax.C:334
void setVectorComponentParameter(const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< T >> *param, bool in_global, GlobalParamsAction *global_block)
Template method for setting several multivalue "scalar" type parameter read from the input file or co...
Definition: Builder.C:1723
ActionIterator actionBlocksWithActionEnd(const std::string &task)
void addParam(const std::string &name, const S &value, const std::string &doc_string)
These methods add an optional parameter and a documentation string to the InputParameters object...
Factory & _factory
The Factory associated with that MooseApp.
Definition: Builder.h:226
Eigen::Matrix< Real, Eigen::Dynamic, 1 > RealEigenVector
Definition: MooseTypes.h:142
virtual ~Builder()
Definition: Builder.C:138
std::vector< std::string > listValidParams(std::string &section_name)
Definition: Builder.C:162
void setHitNode(const std::string &param, const hit::Node &node, const SetParamHitNodeKey)
Sets the hit node associated with the parameter param to node.
MOOSE now contains C++17 code, so give a reasonable error message stating what the user can do to add...
Builder(MooseApp &app, ActionWarehouse &action_wh, std::shared_ptr< Parser > parser)
Definition: Builder.C:122
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type...
std::vector< std::string > findSimilar(std::string param, std::vector< std::string > options)
Definition: Builder.C:97
T & setParam(const std::string &name)
ActionWarehouse & _action_wh
Action warehouse that will be filled by actions.
Definition: Builder.h:228
std::string deprecatedActionSyntaxMessage(const std::string syntax)
Returns the deprecation message for a given syntax that has been deprecated by deprecateActionSyntax...
Definition: Syntax.C:194
ActionIterator actionBlocksWithActionBegin(const std::string &task)
Iterators to the Actions in the warehouse.
void collapseSyntaxNesting(bool collapse)
Mutators for controlling whether or not the outermost level of syntax will be collapsed when printed...
bool isSectionActive(std::string path, hit::Node *root)
Definition: Builder.C:60
void ErrorVector unsigned int
auto index_range(const T &sizable)
The Reporter system is comprised of objects that can contain any number of data values.
Definition: ReporterName.h:30
std::vector< std::string > errors
Definition: Parser.h:54
void remove(const std::string &name)
This function is here to remove parameters of a type so that global parameters can potentially use th...
void walk(const std::string &fullpath, const std::string &nodepath, hit::Node *n)
Definition: Builder.C:311