Loading [MathJax]/extensions/tex2jax.js
https://mooseframework.inl.gov
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends
MultiApp.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 "MultiApp.h"
12 
13 #include "AppFactory.h"
14 #include "AuxiliarySystem.h"
15 #include "DisplacedProblem.h"
16 #include "Console.h"
17 #include "Executioner.h"
18 #include "FEProblem.h"
19 #include "MooseMesh.h"
20 #include "MooseUtils.h"
21 #include "OutputWarehouse.h"
22 #include "SetupInterface.h"
23 #include "UserObject.h"
24 #include "CommandLine.h"
25 #include "Conversion.h"
26 #include "NonlinearSystemBase.h"
27 #include "DelimitedFileReader.h"
28 #include "MooseAppCoordTransform.h"
29 #include "MultiAppTransfer.h"
30 #include "Positions.h"
31 #include "Transient.h"
32 #include "Backup.h"
33 #include "Parser.h"
34 
35 #include "libmesh/mesh_tools.h"
36 #include "libmesh/numeric_vector.h"
37 
38 // C++ includes
39 #include <fstream>
40 #include <iomanip>
41 #include <iterator>
42 #include <algorithm>
43 
44 // Call to "uname"
45 #ifdef LIBMESH_HAVE_SYS_UTSNAME_H
46 #include <sys/utsname.h>
47 #endif
48 
51 {
53  params += SetupInterface::validParams();
54 
55  params.addParam<bool>("use_displaced_mesh",
56  false,
57  "Whether or not this object should use the "
58  "displaced mesh for computation. Note that "
59  "in the case this is true but no "
60  "displacements are provided in the Mesh block "
61  "the undisplaced mesh will still be used.");
62 
63  std::ostringstream app_types_strings;
64  for (const auto & name_bi_pair : AppFactory::instance().registeredObjects())
65  app_types_strings << name_bi_pair.first << " ";
66  MooseEnum app_types_options(app_types_strings.str(), "", true);
67 
68  // Dynamic loading
69  params.addParam<MooseEnum>("app_type",
70  app_types_options,
71  "The type of application to build (applications not "
72  "registered can be loaded with dynamic libraries. Parent "
73  "application type will be used if not provided.");
74  params.addParam<std::string>("library_path",
75  "",
76  "Path to search for dynamic libraries (please "
77  "avoid committing absolute paths in addition to "
78  "MOOSE_LIBRARY_PATH)");
79  params.addParam<std::string>(
80  "library_name",
81  "",
82  "The file name of the library (*.la file) that will be dynamically loaded.");
83  params.addParam<bool>("library_load_dependencies",
84  false,
85  "Tells MOOSE to manually load library dependencies. This should not be "
86  "necessary and is here for debugging/troubleshooting.");
87 
88  // Subapp positions
89  params.addParam<std::vector<Point>>(
90  "positions",
91  "The positions of the App locations. Each set of 3 values will represent a "
92  "Point. This and 'positions_file' cannot be both supplied. If this and "
93  "'positions_file'/'_objects' are not supplied, a single position (0,0,0) will be used");
94  params.addParam<std::vector<FileName>>("positions_file",
95  "Filename(s) that should be looked in for positions. Each"
96  " set of 3 values in that file will represent a Point. "
97  "This and 'positions(_objects)' cannot be both supplied");
98  params.addParam<std::vector<PositionsName>>("positions_objects",
99  "The name of a Positions object that will contain "
100  "the locations of the sub-apps created. This and "
101  "'positions(_file)' cannot be both supplied");
102  params.addParam<bool>(
103  "output_in_position",
104  false,
105  "If true this will cause the output from the MultiApp to be 'moved' by its position vector");
106  params.addParam<bool>(
107  "run_in_position",
108  false,
109  "If true this will cause the mesh from the MultiApp to be 'moved' by its position vector");
110 
111  params.addRequiredParam<std::vector<FileName>>(
112  "input_files",
113  "The input file for each App. If this parameter only contains one input file "
114  "it will be used for all of the Apps. When using 'positions_from_file' it is "
115  "also admissable to provide one input_file per file.");
116  params.addParam<Real>("bounding_box_inflation",
117  0.01,
118  "Relative amount to 'inflate' the bounding box of this MultiApp.");
119  params.addParam<Point>("bounding_box_padding",
120  RealVectorValue(),
121  "Additional padding added to the dimensions of the bounding box. The "
122  "values are added to the x, y and z dimension respectively.");
123 
124  params.addPrivateParam<MPI_Comm>("_mpi_comm");
125 
126  // Set the default execution time
127  params.set<ExecFlagEnum>("execute_on", true) = EXEC_TIMESTEP_BEGIN;
128  // Add the POST_ADAPTIVITY execution flag.
129 #ifdef LIBMESH_ENABLE_AMR
130  ExecFlagEnum & exec_enum = params.set<ExecFlagEnum>("execute_on");
132  params.setDocString("execute_on", exec_enum.getDocString());
133 #endif
134 
135  params.addParam<processor_id_type>("max_procs_per_app",
137  "Maximum number of processors to give to each App in this "
138  "MultiApp. Useful for restricting small solves to just a few "
139  "procs so they don't get spread out");
140  params.addParam<processor_id_type>("min_procs_per_app",
141  1,
142  "Minimum number of processors to give to each App in this "
143  "MultiApp. Useful for larger, distributed mesh solves.");
144  params.addParam<bool>(
145  "wait_for_first_app_init",
146  false,
147  "Create the first sub-application on rank 0, then MPI_Barrier before "
148  "creating the next N-1 apps (on all ranks). "
149  "This is only needed if your sub-application needs to perform some setup "
150  "actions in quiet, without other sub-applications working at the same time.");
151 
152  params.addParam<Real>("global_time_offset",
153  0,
154  "The time offset relative to the parent application for the purpose of "
155  "starting a subapp at a different time from the parent application. The "
156  "global time will be ahead by the offset specified here.");
157 
158  // Resetting subapps
159  params.addParam<std::vector<Real>>(
160  "reset_time",
161  {},
162  "The time(s) at which to reset Apps given by the 'reset_apps' parameter. "
163  "Resetting an App means that it is destroyed and recreated, possibly "
164  "modeling the insertion of 'new' material for that app.");
165  params.addParam<std::vector<unsigned int>>(
166  "reset_apps",
167  {},
168  "The Apps that will be reset when 'reset_time' is hit. These are the App "
169  "'numbers' starting with 0 corresponding to the order of the App positions. "
170  "Resetting an App means that it is destroyed and recreated, possibly modeling "
171  "the insertion of 'new' material for that app.");
172 
173  // Moving subapps
174  params.addParam<Real>(
175  "move_time",
177  "The time at which Apps designated by move_apps are moved to move_positions.");
178 
179  params.addParam<std::vector<unsigned int>>(
180  "move_apps",
181  {},
182  "Apps, designated by their 'numbers' starting with 0 corresponding to the order "
183  "of the App positions, to be moved at move_time to move_positions");
184  params.addParam<std::vector<Point>>(
185  "move_positions", {}, "The positions corresponding to each move_app.");
186 
187  params.addParam<std::vector<CLIArgString>>(
188  "cli_args",
189  {},
190  "Additional command line arguments to pass to the sub apps. If one set is provided the "
191  "arguments are applied to all, otherwise there must be a set for each sub app.");
192 
193  params.addParam<std::vector<FileName>>(
194  "cli_args_files",
195  "File names that should be looked in for additional command line arguments "
196  "to pass to the sub apps. Each line of a file is set to each sub app. If only "
197  "one line is provided, it will be applied to all sub apps.");
198 
199  // Fixed point iterations
200  params.addRangeCheckedParam<Real>("relaxation_factor",
201  1.0,
202  "relaxation_factor>0 & relaxation_factor<2",
203  "Fraction of newly computed value to keep."
204  "Set between 0 and 2.");
205  params.addDeprecatedParam<std::vector<std::string>>(
206  "relaxed_variables",
207  {},
208  "Use transformed_variables.",
209  "List of subapp variables to relax during Multiapp coupling iterations");
210  params.addParam<std::vector<std::string>>(
211  "transformed_variables",
212  {},
213  "List of subapp variables to use coupling algorithm on during Multiapp coupling iterations");
214  params.addParam<std::vector<PostprocessorName>>(
215  "transformed_postprocessors",
216  {},
217  "List of subapp postprocessors to use coupling "
218  "algorithm on during Multiapp coupling iterations");
219  params.addParam<bool>("keep_solution_during_restore",
220  false,
221  "This is useful when doing MultiApp coupling iterations. It takes the "
222  "final solution from the previous coupling iteration"
223  "and re-uses it as the initial guess for the next coupling iteration");
224  params.addParam<bool>("keep_aux_solution_during_restore",
225  false,
226  "This is useful when doing MultiApp coupling iterations. It takes the "
227  "final auxiliary solution from the previous coupling iteration"
228  "and re-uses it as the initial guess for the next coupling iteration");
229  params.addParam<bool>(
230  "no_backup_and_restore",
231  false,
232  "True to turn off restore for this multiapp. This is useful when doing steady-state "
233  "Picard iterations where we want to use the solution of previous Picard iteration as the "
234  "initial guess of the current Picard iteration.");
235  params.addParam<unsigned int>(
236  "max_multiapp_level",
237  10,
238  "Integer set by user that will stop the simulation if the multiapp level "
239  "exceeds it. Useful for preventing infinite loops with multiapp simulations");
240  params.deprecateParam("no_backup_and_restore", "no_restore", "01/01/2025");
241 
242  params.addDeprecatedParam<bool>("clone_master_mesh",
243  false,
244  "True to clone parent app mesh and use it for this MultiApp.",
245  "clone_master_mesh is deprecated, use clone_parent_mesh instead");
246  params.addParam<bool>(
247  "clone_parent_mesh", false, "True to clone parent app mesh and use it for this MultiApp.");
248 
249  params.addPrivateParam<std::shared_ptr<CommandLine>>("_command_line");
250  params.addPrivateParam<bool>("use_positions", true);
251  params.declareControllable("enable");
252  params.declareControllable("cli_args", {EXEC_PRE_MULTIAPP_SETUP});
253  params.registerBase("MultiApp");
254 
255  params.addParamNamesToGroup("use_displaced_mesh wait_for_first_app_init max_multiapp_level",
256  "Advanced");
257  params.addParamNamesToGroup("positions positions_file positions_objects run_in_position "
258  "output_in_position",
259  "Positions / transformations of the MultiApp frame of reference");
260  params.addParamNamesToGroup("min_procs_per_app max_procs_per_app", "Parallelism");
261  params.addParamNamesToGroup("reset_time reset_apps", "Reset MultiApp");
262  params.addParamNamesToGroup("move_time move_apps move_positions", "Timed move of MultiApps");
263  params.addParamNamesToGroup("relaxation_factor transformed_variables transformed_postprocessors "
264  "keep_solution_during_restore keep_aux_solution_during_restore "
265  "no_restore",
266  "Fixed point iteration");
267  params.addParamNamesToGroup("library_name library_path library_load_dependencies",
268  "Dynamic loading");
269  params.addParamNamesToGroup("cli_args cli_args_files", "Passing command line argument");
270  return params;
271 }
272 
274  : MooseObject(parameters),
275  SetupInterface(this),
276  Restartable(this, "MultiApps"),
277  PerfGraphInterface(this, std::string("MultiApp::") + _name),
278  _fe_problem(*getCheckedPointerParam<FEProblemBase *>("_fe_problem_base")),
279  _app_type(isParamValid("app_type") ? std::string(getParam<MooseEnum>("app_type"))
280  : _fe_problem.getMooseApp().type()),
281  _use_positions(getParam<bool>("use_positions")),
282  _input_files(getParam<std::vector<FileName>>("input_files")),
283  _wait_for_first_app_init(getParam<bool>("wait_for_first_app_init")),
284  _total_num_apps(0),
285  _my_num_apps(0),
286  _first_local_app(0),
287  _orig_comm(_communicator.get()),
288  _my_communicator(),
289  _my_comm(_my_communicator.get()),
290  _my_rank(0),
291  _inflation(getParam<Real>("bounding_box_inflation")),
292  _bounding_box_padding(getParam<Point>("bounding_box_padding")),
293  _max_procs_per_app(getParam<processor_id_type>("max_procs_per_app")),
294  _min_procs_per_app(getParam<processor_id_type>("min_procs_per_app")),
295  _output_in_position(getParam<bool>("output_in_position")),
296  _global_time_offset(getParam<Real>("global_time_offset")),
297  _reset_times(getParam<std::vector<Real>>("reset_time")),
298  _reset_apps(getParam<std::vector<unsigned int>>("reset_apps")),
299  _reset_happened(false),
300  _move_time(getParam<Real>("move_time")),
301  _move_apps(getParam<std::vector<unsigned int>>("move_apps")),
302  _move_positions(getParam<std::vector<Point>>("move_positions")),
303  _move_happened(false),
304  _has_an_app(true),
305  _cli_args(getParam<std::vector<CLIArgString>>("cli_args")),
306  _keep_solution_during_restore(getParam<bool>("keep_solution_during_restore")),
307  _keep_aux_solution_during_restore(getParam<bool>("keep_aux_solution_during_restore")),
308  _no_restore(getParam<bool>("no_restore")),
309  _run_in_position(getParam<bool>("run_in_position")),
310  _sub_app_backups(declareRestartableDataWithContext<SubAppBackups>("sub_app_backups", this)),
311  _solve_step_timer(registerTimedSection("solveStep", 3, "Executing MultiApps", false)),
312  _init_timer(registerTimedSection("init", 3, "Initializing MultiApp")),
313  _backup_timer(registerTimedSection("backup", 3, "Backing Up MultiApp")),
314  _restore_timer(registerTimedSection("restore", 3, "Restoring MultiApp")),
315  _reset_timer(registerTimedSection("resetApp", 3, "Resetting MultiApp"))
316 {
317  if (parameters.isParamSetByUser("cli_args") && parameters.isParamValid("cli_args") &&
318  parameters.isParamValid("cli_args_files"))
319  paramError("cli_args",
320  "'cli_args' and 'cli_args_files' cannot be specified simultaneously in MultiApp ");
321 
322  if (!_use_positions && (isParamValid("positions") || isParamValid("positions_file") ||
323  isParamValid("positions_objects")))
324  paramError("use_positions",
325  "This MultiApps has been set to not use positions, "
326  "but a 'positions' parameter has been set.");
327 
328  if ((_reset_apps.size() > 0 && _reset_times.size() == 0) ||
329  (_reset_apps.size() == 0 && _reset_times.size() > 0))
330  mooseError("reset_time and reset_apps may only be specified together");
331 
332  // Check that the reset times are sorted by the user
333  auto sorted_times = _reset_times;
334  std::sort(sorted_times.begin(), sorted_times.end());
335  if (_reset_times.size() && _reset_times != sorted_times)
336  paramError("reset_time", "List of reset times must be sorted in increasing order");
337 }
338 
339 void
340 MultiApp::init(unsigned int num_apps, bool batch_mode)
341 {
342  auto config = rankConfig(
343  processor_id(), n_processors(), num_apps, _min_procs_per_app, _max_procs_per_app, batch_mode);
344  init(num_apps, config);
345 }
346 
347 void
348 MultiApp::init(unsigned int num_apps, const LocalRankConfig & config)
349 {
350  TIME_SECTION(_init_timer);
351 
352  _total_num_apps = num_apps;
353  _rank_config = config;
354  buildComm();
356 
357  _has_bounding_box.resize(_my_num_apps, false);
358  _reset_happened.resize(_reset_times.size(), false);
359  _bounding_box.resize(_my_num_apps);
360 
361  if ((_cli_args.size() > 1) && (_total_num_apps != _cli_args.size()))
362  paramError("cli_args",
363  "The number of items supplied must be 1 or equal to the number of sub apps.");
364 
365  // if cliArgs() != _cli_args, then cliArgs() was overridden and we need to check it
366  auto cla = cliArgs();
367  if (cla != std::vector<std::string>(_cli_args.begin(), _cli_args.end()))
368  {
369  if ((cla.size() > 1) && (_total_num_apps != cla.size()))
370  mooseError("The number of items supplied as command line argument to subapps must be 1 or "
371  "equal to the number of sub apps. Note: you use a multiapp that provides its own "
372  "command line parameters so the error is not in cli_args");
373  }
374 }
375 
376 void
378 {
379  if (_use_positions)
380  {
381  fillPositions();
382  init(_positions.size());
383  createApps();
384  }
385 }
386 
387 void
389 {
390  if (!_has_an_app)
391  return;
392 
393  TIME_SECTION("createApps", 2, "Instantiating Sub-Apps", false);
394 
395  // Read commandLine arguments that will be used when creating apps
397 
399 
400  _apps.resize(_my_num_apps);
401 
402  // If the user provided an unregistered app type, see if we can load it dynamically
403  if (!AppFactory::instance().isRegistered(_app_type))
405  getParam<std::string>("library_path"),
406  getParam<std::string>("library_name"),
407  getParam<bool>("library_load_dependencies"));
408 
409  bool rank_did_quiet_init = false;
410  unsigned int local_app = libMesh::invalid_uint;
412  {
413  if (hasLocalApp(0))
414  {
415  rank_did_quiet_init = true;
416  local_app = globalAppToLocal(0);
417  createLocalApp(local_app);
418  }
419 
420  MPI_Barrier(_orig_comm);
421  }
422 
423  for (unsigned int i = 0; i < _my_num_apps; i++)
424  {
425  if (rank_did_quiet_init && i == local_app)
426  continue;
427  createLocalApp(i);
428  }
429 }
430 
431 void
432 MultiApp::createLocalApp(const unsigned int i)
433 {
435 }
436 
437 void
439 {
440  if (!_use_positions)
441  // if not using positions, we create the sub-apps in initialSetup instead of right after
442  // construction of MultiApp
443  createApps();
444 }
445 
446 void
448 {
449  if (isParamValid("cli_args_files"))
450  {
451  _cli_args_from_file.clear();
452 
453  std::vector<FileName> cli_args_files = getParam<std::vector<FileName>>("cli_args_files");
454  std::vector<FileName> input_files = getParam<std::vector<FileName>>("input_files");
455 
456  // If we use parameter "cli_args_files", at least one file should be provided
457  if (!cli_args_files.size())
458  paramError("cli_args_files", "You need to provide at least one commandLine argument file ");
459 
460  // If we multiple input files, then we need to check if the number of input files
461  // match with the number of argument files
462  if (cli_args_files.size() != 1 && cli_args_files.size() != input_files.size())
463  paramError("cli_args_files",
464  "The number of commandLine argument files ",
465  cli_args_files.size(),
466  " for MultiApp ",
467  name(),
468  " must either be only one or match the number of input files ",
469  input_files.size());
470 
471  // Go through all argument files
472  std::vector<std::string> cli_args;
473  for (unsigned int p_file_it = 0; p_file_it < cli_args_files.size(); p_file_it++)
474  {
475  std::string cli_args_file = cli_args_files[p_file_it];
476  // Clear up
477  cli_args.clear();
478  // Read the file on the root processor then broadcast it
479  if (processor_id() == 0)
480  {
481  MooseUtils::checkFileReadable(cli_args_file);
482 
483  std::ifstream is(cli_args_file.c_str());
484  std::copy(std::istream_iterator<std::string>(is),
485  std::istream_iterator<std::string>(),
486  std::back_inserter(cli_args));
487 
488  // We do not allow empty files
489  if (!cli_args.size())
490  paramError("cli_args_files",
491  "There is no commandLine argument in the commandLine argument file ",
492  cli_args_file);
493 
494  // If we have position files, we need to
495  // make sure the number of commandLine argument strings
496  // match with the number of positions
497  if (_npositions_inputfile.size())
498  {
499  auto num_positions = _npositions_inputfile[p_file_it];
500  // Check if the number of commandLine argument strings equal to
501  // the number of positions
502  if (cli_args.size() == 1)
503  for (MooseIndex(num_positions) num = 0; num < num_positions; num++)
504  _cli_args_from_file.push_back(cli_args.front());
505  else if (cli_args.size() == num_positions)
506  for (auto && cli_arg : cli_args)
507  _cli_args_from_file.push_back(cli_arg);
508  else if (cli_args.size() != num_positions)
509  paramError("cli_args_files",
510  "The number of commandLine argument strings ",
511  cli_args.size(),
512  " in the file ",
513  cli_args_file,
514  " must either be only one or match the number of positions ",
515  num_positions);
516  }
517  else
518  {
519  // If we do not have position files, we will check if the number of
520  // commandLine argument strings match with the total number of subapps
521  for (auto && cli_arg : cli_args)
522  _cli_args_from_file.push_back(cli_arg);
523  }
524  }
525  }
526 
527  // Broad cast all arguments to everyone
529  }
530 
531  if (_cli_args_from_file.size() && _cli_args_from_file.size() != 1 &&
533  mooseError(" The number of commandLine argument strings ",
534  _cli_args_from_file.size(),
535  " must either be only one or match the total "
536  "number of sub apps ",
538 
539  if (_cli_args_from_file.size() && cliArgs().size())
540  mooseError("Cannot set commandLine arguments from both input_file and external files");
541 }
542 
543 void
545 {
546  if (_move_apps.size() != _move_positions.size())
547  mooseError("The number of apps to move and the positions to move them to must be the same for "
548  "MultiApp ",
549  _name);
550 
551  if (isParamValid("positions") + isParamValid("positions_file") +
552  isParamValid("positions_objects") >
553  1)
554  mooseError("Only one 'positions' parameter may be specified");
555 
556  if (isParamValid("positions"))
557  {
558  _positions = getParam<std::vector<Point>>("positions");
559 
560  if (_positions.size() < _input_files.size())
561  mooseError("Not enough positions for the number of input files provided in MultiApp ",
562  name());
563  }
564  else if (isParamValid("positions_file"))
565  {
566  std::vector<FileName> positions_files = getParam<std::vector<FileName>>("positions_file");
567  std::vector<FileName> input_files = getParam<std::vector<FileName>>("input_files");
568 
569  if (input_files.size() != 1 && positions_files.size() != input_files.size())
570  mooseError("Number of input_files for MultiApp ",
571  name(),
572  " must either be only one or match the number of positions_file files");
573 
574  // Clear out the _input_files because we're going to rebuild it
575  if (input_files.size() != 1)
576  _input_files.clear();
577 
578  for (unsigned int p_file_it = 0; p_file_it < positions_files.size(); p_file_it++)
579  {
580  std::string positions_file = positions_files[p_file_it];
581  MooseUtils::DelimitedFileReader file(positions_file, &_communicator);
583  file.read();
584 
585  const std::vector<Point> & data = file.getDataAsPoints();
586  for (const auto & d : data)
587  _positions.push_back(d);
588 
589  // Save the number of positions for this input file
590  _npositions_inputfile.push_back(data.size());
591 
592  for (unsigned int i = 0; i < data.size(); ++i)
593  if (input_files.size() != 1)
594  _input_files.push_back(input_files[p_file_it]);
595  }
596  }
597  else if (isParamValid("positions_objects"))
598  {
599  const auto & positions_param_objs = getParam<std::vector<PositionsName>>("positions_objects");
600  const auto & input_files = getParam<std::vector<FileName>>("input_files");
601 
602  if (input_files.size() != 1 && positions_param_objs.size() != input_files.size())
603  mooseError("Number of input_files for MultiApp ",
604  name(),
605  " must either be only one or match the number of positions_objects specified");
606 
607  // Clear out the _input_files because we're going to rebuild it
608  if (input_files.size() != 1)
609  _input_files.clear();
610 
611  // Keeps track of where each positions object start in terms of subapp numbers
612  unsigned int offset = 0;
613 
614  for (const auto p_obj_it : index_range(positions_param_objs))
615  {
616  const std::string & positions_name = positions_param_objs[p_obj_it];
617  auto positions_obj = &_fe_problem.getPositionsObject(positions_name);
618 
619  const auto & data = positions_obj->getPositions(true);
620 
621  // Append all positions from this object
622  for (const auto & d : data)
623  _positions.push_back(d);
624 
625  // Save the number of positions for this input file
626  _npositions_inputfile.push_back(data.size());
627 
628  if (!positions_obj)
629  paramError("positions_objects",
630  "'" + positions_name + "' is not of the expected type. Should be a Positions");
631 
632  // Keep track of which positions is tied to what subapp
633  for (unsigned int i = 0; i < data.size(); ++i)
634  {
635  if (input_files.size() != 1)
636  _input_files.push_back(input_files[p_obj_it]);
637  _positions_objs.push_back(positions_obj);
638  _positions_index_offsets.push_back(offset);
639  }
640  offset += data.size();
641  }
642  }
643  else
644  {
645  _positions = {Point()};
646 
647  if (_positions.size() < _input_files.size())
648  mooseError("Not enough positions for the number of input files provided in MultiApp ",
649  name());
650  }
651 
652  mooseAssert(_input_files.size() == 1 || _positions.size() == _input_files.size(),
653  "Number of positions and input files are not the same!");
654 }
655 
656 void
657 MultiApp::preTransfer(Real /*dt*/, Real target_time)
658 {
659  // Get a transient executioner to get a user-set tolerance
660  Real timestep_tol = 1e-13;
661  if (dynamic_cast<TransientBase *>(_fe_problem.getMooseApp().getExecutioner()))
662  timestep_tol =
663  dynamic_cast<TransientBase *>(_fe_problem.getMooseApp().getExecutioner())->timestepTol();
664 
665  // First, see if any Apps need to be reset
666  for (unsigned int i = 0; i < _reset_times.size(); i++)
667  {
668  if (!_reset_happened[i] && (target_time + timestep_tol >= _reset_times[i]))
669  {
670  _reset_happened[i] = true;
671  if (_reset_apps.size() > 0)
672  for (auto & app : _reset_apps)
673  resetApp(app);
674 
675  // If we reset an application, then we delete the old objects, including the coordinate
676  // transformation classes. Consequently we need to reset the coordinate transformation classes
677  // in the associated transfer classes
678  for (auto * const transfer : _associated_transfers)
679  transfer->getAppInfo();
680 
681  // Similarly we need to transform the mesh again
682  if (_run_in_position)
683  for (const auto i : make_range(_my_num_apps))
684  {
685  auto app_ptr = _apps[i];
686  if (usingPositions())
687  app_ptr->getExecutioner()->feProblem().coordTransform().transformMesh(
688  app_ptr->getExecutioner()->feProblem().mesh(), _positions[_first_local_app + i]);
689  else
690  app_ptr->getExecutioner()->feProblem().coordTransform().transformMesh(
691  app_ptr->getExecutioner()->feProblem().mesh(), Point(0, 0, 0));
692  }
693 
694  // If the time step covers multiple reset times, set them all as having 'happened'
695  for (unsigned int j = i; j < _reset_times.size(); j++)
696  if (target_time + timestep_tol >= _reset_times[j])
697  _reset_happened[j] = true;
698 
699  break;
700  }
701  }
702 
703  // Now move any apps that should be moved
704  if (_use_positions && !_move_happened && target_time + timestep_tol >= _move_time)
705  {
706  _move_happened = true;
707  for (unsigned int i = 0; i < _move_apps.size(); i++)
709  }
710 }
711 
712 Executioner *
713 MultiApp::getExecutioner(unsigned int app)
714 {
715  if (!_has_an_app)
716  mooseError("No app for ", name(), " on processor ", _orig_rank);
717 
718  return _apps[globalAppToLocal(app)]->getExecutioner();
719 }
720 
721 void
723 {
724  for (const auto & app_ptr : _apps)
725  {
726  auto * executioner = app_ptr->getExecutioner();
727  mooseAssert(executioner, "Executioner is nullptr");
728 
729  executioner->feProblem().execute(EXEC_FINAL);
730  executioner->feProblem().outputStep(EXEC_FINAL);
731  }
732 }
733 
734 void
736 {
737  for (const auto & app_ptr : _apps)
738  {
739  auto * executioner = app_ptr->getExecutioner();
740  mooseAssert(executioner, "Executioner is nullptr");
741 
742  executioner->postExecute();
743  }
744 }
745 
746 void
748 {
749  TIME_SECTION(_backup_timer);
750 
752  _console << "Backed up MultiApp ... ";
753 
754  for (unsigned int i = 0; i < _my_num_apps; i++)
755  _sub_app_backups[i] = _apps[i]->backup();
756 
758  _console << name() << std::endl;
759 }
760 
761 void
762 MultiApp::restore(bool force)
763 {
764  TIME_SECTION(_restore_timer);
765 
766  if (force || needsRestoration())
767  {
768  // Must be restarting / recovering from main app so hold off on restoring
769  // Instead - the restore will happen in sub-apps' initialSetup()
770  // Note that _backups was already populated by dataLoad() in the main app
772  return;
773 
774  // We temporarily copy and store solutions for all subapps
776  {
778 
779  for (unsigned int i = 0; i < _my_num_apps; i++)
780  {
781  _end_solutions[i] = _apps[i]
782  ->getExecutioner()
783  ->feProblem()
784  .getNonlinearSystemBase(/*nl_sys=*/0)
785  .solution()
786  .clone();
787  auto & sub_multiapps =
788  _apps[i]->getExecutioner()->feProblem().getMultiAppWarehouse().getObjects();
789 
790  // multiapps of each subapp should do the same things
791  // It is implemented recursively
792  for (auto & multi_app : sub_multiapps)
793  multi_app->keepSolutionDuringRestore(_keep_solution_during_restore);
794  }
795  }
796 
797  // We temporarily copy and store solutions for all subapps
799  {
801 
802  for (unsigned int i = 0; i < _my_num_apps; i++)
803  _end_aux_solutions[i] =
805  }
806 
808  _console << "Restoring MultiApp ... ";
809 
810  for (unsigned int i = 0; i < _my_num_apps; i++)
811  {
812  _apps[i]->restore(std::move(_sub_app_backups[i]), false);
813  _sub_app_backups[i] = _apps[i]->finalizeRestore();
814  mooseAssert(_sub_app_backups[i], "Should have a backup");
815  }
816 
818  _console << name() << std::endl;
819 
820  // Now copy the latest solutions back for each subapp
822  {
823  for (unsigned int i = 0; i < _my_num_apps; i++)
824  {
825  _apps[i]->getExecutioner()->feProblem().getNonlinearSystemBase(/*nl_sys=*/0).solution() =
826  *_end_solutions[i];
827 
828  // We need to synchronize solution so that local_solution has the right values
829  _apps[i]->getExecutioner()->feProblem().getNonlinearSystemBase(/*nl_sys=*/0).update();
830  }
831 
832  _end_solutions.clear();
833  }
834  // Now copy the latest auxiliary solutions back for each subapp
836  {
837  for (unsigned int i = 0; i < _my_num_apps; i++)
838  {
839  _apps[i]->getExecutioner()->feProblem().getAuxiliarySystem().solution() =
840  *_end_aux_solutions[i];
841 
842  // We need to synchronize solution so that local_solution has the right values
843  _apps[i]->getExecutioner()->feProblem().getAuxiliarySystem().update();
844  }
845 
846  _end_aux_solutions.clear();
847  }
848  }
849  else
850  {
851  for (unsigned int i = 0; i < _my_num_apps; i++)
852  {
853  for (auto & sub_app :
854  _apps[i]->getExecutioner()->feProblem().getMultiAppWarehouse().getObjects())
855  sub_app->restore(false);
856  }
857  }
858 }
859 
860 void
861 MultiApp::keepSolutionDuringRestore(bool keep_solution_during_restore)
862 {
863  if (_pars.isParamSetByUser("keep_solution_during_restore"))
864  paramError("keep_solution_during_restore",
865  "This parameter should only be provided in parent app");
866 
867  _keep_solution_during_restore = keep_solution_during_restore;
868 }
869 
870 void
871 MultiApp::transformBoundingBox(BoundingBox & box, const MultiAppCoordTransform & transform)
872 {
873  const Real min_x = box.first(0);
874  const Real max_x = box.second(0);
875  const Real min_y = box.first(1);
876  const Real max_y = box.second(1);
877  const Real min_z = box.first(2);
878  const Real max_z = box.second(2);
879 
880  std::array<Point, 8> box_corners = {{Point(min_x, min_y, min_z),
881  Point(max_x, min_y, min_z),
882  Point(min_x, max_y, min_z),
883  Point(max_x, max_y, min_z),
884  Point(min_x, min_y, max_z),
885  Point(max_x, min_y, max_z),
886  Point(min_x, max_y, max_z),
887  Point(max_x, max_y, max_z)}};
888 
889  // transform each corner
890  for (auto & corner : box_corners)
891  corner = transform(corner);
892 
893  // Create new bounding box
894  Point new_box_min = box_corners[0];
895  Point new_box_max = new_box_min;
896  for (const auto p : make_range(1, 8))
897  for (const auto d : make_range(Moose::dim))
898  {
899  const Point & pt = box_corners[p];
900  if (new_box_min(d) > pt(d))
901  new_box_min(d) = pt(d);
902 
903  if (new_box_max(d) < pt(d))
904  new_box_max(d) = pt(d);
905  }
906  box.first = new_box_min;
907  box.second = new_box_max;
908 }
909 
910 BoundingBox
911 MultiApp::getBoundingBox(unsigned int app,
912  bool displaced_mesh,
913  const MultiAppCoordTransform * const coord_transform)
914 {
915  if (!_has_an_app)
916  mooseError("No app for ", name(), " on processor ", _orig_rank);
917 
918  unsigned int local_app = globalAppToLocal(app);
919  FEProblemBase & fe_problem_base = _apps[local_app]->getExecutioner()->feProblem();
920  MooseMesh & mesh = (displaced_mesh && fe_problem_base.getDisplacedProblem().get() != NULL)
921  ? fe_problem_base.getDisplacedProblem()->mesh()
922  : fe_problem_base.mesh();
923 
924  {
926  if (displaced_mesh)
927  _bounding_box[local_app] = MeshTools::create_bounding_box(mesh);
928  else
929  {
930  if (!_has_bounding_box[local_app])
931  {
932  _bounding_box[local_app] = MeshTools::create_bounding_box(mesh);
933  _has_bounding_box[local_app] = true;
934  }
935  }
936  }
937  BoundingBox bbox = _bounding_box[local_app];
938 
939  Point min = bbox.min();
941  Point max = bbox.max();
943 
944  Point inflation_amount = (max - min) * _inflation;
945 
946  Point inflated_min = min - inflation_amount;
947  Point inflated_max = max + inflation_amount;
948 
949  Point shifted_min = inflated_min;
950  Point shifted_max = inflated_max;
951 
952  if ((!coord_transform || coord_transform->skipCoordinateCollapsing()) &&
953  fe_problem_base.getCoordSystem(*(mesh.meshSubdomains().begin())) == Moose::COORD_RZ)
954  {
955  // If the problem is RZ then we're going to invent a box that would cover the whole "3D" app
956  // FIXME: Assuming all subdomains are the same coordinate system type!
957  shifted_min(0) = -inflated_max(0);
958  shifted_min(1) = inflated_min(1);
959  shifted_min(2) = -inflated_max(0);
960 
961  shifted_max(0) = inflated_max(0);
962  shifted_max(1) = inflated_max(1);
963  shifted_max(2) = inflated_max(0);
964  }
965 
966  if (coord_transform)
967  {
968  BoundingBox transformed_bbox(shifted_min, shifted_max);
969  transformBoundingBox(transformed_bbox, *coord_transform);
970  return transformed_bbox;
971  }
972  else
973  {
974  // This is where the app is located. We need to shift by this amount.
975  Point p = position(app);
976 
977  // Shift them to the position they're supposed to be
978  shifted_min += p;
979  shifted_max += p;
980  return BoundingBox(shifted_min, shifted_max);
981  }
982 }
983 
985 MultiApp::appProblemBase(unsigned int app)
986 {
987  if (!_has_an_app)
988  mooseError("No app for ", name(), " on processor ", _orig_rank);
989 
990  unsigned int local_app = globalAppToLocal(app);
991 
992  return _apps[local_app]->getExecutioner()->feProblem();
993 }
994 
995 FEProblem &
996 MultiApp::appProblem(unsigned int app)
997 {
999  "MultiApp::appProblem() is deprecated, call MultiApp::appProblemBase() instead.\n");
1000  if (!_has_an_app)
1001  mooseError("No app for ", name(), " on processor ", _orig_rank);
1002 
1003  unsigned int local_app = globalAppToLocal(app);
1004 
1005  return dynamic_cast<FEProblem &>(_apps[local_app]->getExecutioner()->feProblem());
1006 }
1007 
1008 const UserObject &
1009 MultiApp::appUserObjectBase(unsigned int app, const std::string & name)
1010 {
1011  if (!_has_an_app)
1012  mooseError("No app for ", MultiApp::name(), " on processor ", _orig_rank);
1013 
1014  return appProblemBase(app).getUserObjectBase(name);
1015 }
1016 
1017 Real
1018 MultiApp::appPostprocessorValue(unsigned int app, const std::string & name)
1019 {
1020  if (!_has_an_app)
1021  mooseError("No app for ", MultiApp::name(), " on processor ", _orig_rank);
1022 
1024 }
1025 
1027 MultiApp::appTransferVector(unsigned int app, std::string var_name)
1028 {
1029  return *(appProblemBase(app).getSystem(var_name).solution);
1030 }
1031 
1032 bool
1034 {
1036 }
1037 
1038 bool
1039 MultiApp::hasLocalApp(unsigned int global_app) const
1040 {
1041  if (_has_an_app && global_app >= _first_local_app &&
1042  global_app <= _first_local_app + (_my_num_apps - 1))
1043  return true;
1044 
1045  return false;
1046 }
1047 
1048 MooseApp *
1049 MultiApp::localApp(unsigned int local_app)
1050 {
1051  mooseAssert(local_app < _apps.size(), "Index out of range: " + Moose::stringify(local_app));
1052  return _apps[local_app].get();
1053 }
1054 
1055 void
1056 MultiApp::resetApp(unsigned int global_app, Real time)
1057 {
1058  TIME_SECTION(_reset_timer);
1059 
1061 
1062  if (hasLocalApp(global_app))
1063  {
1064  unsigned int local_app = globalAppToLocal(global_app);
1065 
1066  // Extract the file numbers from the output, so that the numbering is maintained after reset
1067  std::map<std::string, unsigned int> m = _apps[local_app]->getOutputWarehouse().getFileNumbers();
1068 
1069  createApp(local_app, time);
1070 
1071  // Reset the file numbers of the newly reset apps
1072  _apps[local_app]->getOutputWarehouse().setFileNumbers(m);
1073  }
1074 }
1075 
1076 void
1077 MultiApp::moveApp(unsigned int global_app, Point p)
1078 {
1079  if (_use_positions)
1080  {
1081  _positions[global_app] = p;
1082 
1083  if (hasLocalApp(global_app))
1084  {
1085  unsigned int local_app = globalAppToLocal(global_app);
1086 
1087  if (_output_in_position)
1088  _apps[local_app]->setOutputPosition(p);
1089  if (_run_in_position)
1090  paramError("run_in_position", "Moving apps and running apps in position is not supported");
1091  }
1092  }
1093 }
1094 
1095 void
1097 {
1099  for (unsigned int i = 0; i < _apps.size(); i++)
1100  _apps[i]->setOutputPosition(_app.getOutputPosition() + _positions[_first_local_app + i]);
1101 }
1102 
1103 void
1104 MultiApp::createApp(unsigned int i, Real start_time)
1105 {
1106  // Define the app name
1107  const std::string multiapp_name = getMultiAppName(name(), _first_local_app + i, _total_num_apps);
1108  std::string full_name;
1109 
1110  // Only add parent name if the parent is not the main app
1111  if (_app.multiAppLevel() > 0)
1112  full_name = _app.name() + "_" + multiapp_name;
1113  else
1114  full_name = multiapp_name;
1115 
1117  app_params.set<FEProblemBase *>("_parent_fep") = &_fe_problem;
1118  app_params.set<std::unique_ptr<Backup> *>("_initial_backup") = &_sub_app_backups[i];
1119 
1120  // Build the CommandLine with the relevant options for this subapp and add the
1121  // cli args from the input file
1122  std::vector<std::string> input_cli_args;
1123  if (cliArgs().size() > 0 || _cli_args_from_file.size() > 0)
1124  input_cli_args = getCommandLineArgs(i);
1125  // This will mark all hit CLI command line parameters that are passed to subapps
1126  // as used within the parent app (_app)
1127  auto app_cli = _app.commandLine()->initSubAppCommandLine(name(), multiapp_name, input_cli_args);
1128  app_cli->parse();
1129  app_params.set<std::shared_ptr<CommandLine>>("_command_line") = std::move(app_cli);
1130 
1132  _console << COLOR_CYAN << "Creating MultiApp " << name() << " of type " << _app_type
1133  << " of level " << _app.multiAppLevel() + 1 << " and number " << _first_local_app + i
1134  << " on processor " << processor_id() << " with full name " << full_name
1135  << COLOR_DEFAULT << std::endl;
1136  app_params.set<unsigned int>("_multiapp_level") = _app.multiAppLevel() + 1;
1137  app_params.set<unsigned int>("_multiapp_number") = _first_local_app + i;
1138  app_params.set<const MooseMesh *>("_master_mesh") = &_fe_problem.mesh();
1139  if (getParam<bool>("clone_master_mesh") || getParam<bool>("clone_parent_mesh"))
1140  {
1142  _console << COLOR_CYAN << "Cloned parent app mesh will be used for MultiApp " << name()
1143  << COLOR_DEFAULT << std::endl;
1144  app_params.set<bool>("_use_master_mesh") = true;
1146  if (displaced_problem)
1147  app_params.set<const MooseMesh *>("_master_displaced_mesh") = &displaced_problem->mesh();
1148  }
1149 
1150  // If only one input file was provided, use it for all the solves
1151  const auto input_index = _input_files.size() == 1 ? 0 : _first_local_app + i;
1152  const auto & input_file = _input_files[input_index];
1153 
1154  // create new parser tree for the application and parse
1155  auto parser = std::make_unique<Parser>(input_file);
1156 
1157  if (input_file.size())
1158  {
1159  parser->parse();
1160  const auto & app_type = parser->getAppType();
1161  if (app_type.empty() && _app_type.empty())
1162  mooseWarning("The application type is not specified for ",
1163  full_name,
1164  ". Please use [Application] block to specify the application type.");
1165  if (!app_type.empty() && app_type != _app_type &&
1166  !AppFactory::instance().isRegistered(app_type))
1167  mooseError("In the ",
1168  full_name,
1169  ", '",
1170  app_type,
1171  "' is not a registered application. The registered application is named: '",
1172  _app_type,
1173  "'. Please double check the [Application] block to make sure the correct "
1174  "application is provided. \n");
1175  }
1176 
1177  if (parser->getAppType().empty())
1178  parser->setAppType(_app_type);
1179 
1180  app_params.set<std::shared_ptr<Parser>>("_parser") = std::move(parser);
1181  _apps[i] = AppFactory::instance().createShared(_app_type, full_name, app_params, _my_comm);
1182  auto & app = _apps[i];
1183 
1184  app->setGlobalTimeOffset(start_time);
1185  app->setOutputFileNumbers(_app.getOutputWarehouse().getFileNumbers());
1186  app->setRestart(_app.isRestarting());
1187  app->setRecover(_app.isRecovering());
1188 
1189  if (_use_positions && getParam<bool>("output_in_position"))
1190  app->setOutputPosition(_app.getOutputPosition() + _positions[_first_local_app + i]);
1192  paramError("run_in_position",
1193  "Sub-apps are already displaced, so they are already output in position");
1194 
1195  // Update the MultiApp level for the app that was just created
1196  app->setupOptions();
1197  // if multiapp does not have file base in Outputs input block, output file base will
1198  // be empty here since setupOptions() does not set the default file base with the multiapp
1199  // input file name. Parent app will create the default file base for multiapp by taking the
1200  // output base of the parent app problem and appending the name of the multiapp plus a number to
1201  // it
1202  if (app->getOutputFileBase().empty())
1204  preRunInputFile();
1205  if (_app.multiAppLevel() > getParam<unsigned int>("max_multiapp_level"))
1206  mooseError("Maximum multiapp level has been reached. This is likely caused by an infinite loop "
1207  "in your multiapp system. If additional multiapp levels are needed, "
1208  "max_multiapp_level can be specified in the MuliApps block.");
1209 
1210  // Transfer coupling relaxation information to the subapps
1211  _apps[i]->fixedPointConfig().sub_relaxation_factor = getParam<Real>("relaxation_factor");
1212  _apps[i]->fixedPointConfig().sub_transformed_vars =
1213  getParam<std::vector<std::string>>("transformed_variables");
1214  // Handle deprecated parameter
1215  if (!parameters().isParamSetByAddParam("relaxed_variables"))
1216  _apps[i]->fixedPointConfig().sub_transformed_vars =
1217  getParam<std::vector<std::string>>("relaxed_variables");
1218  _apps[i]->fixedPointConfig().sub_transformed_pps =
1219  getParam<std::vector<PostprocessorName>>("transformed_postprocessors");
1220 
1221  app->runInputFile();
1222  auto fixed_point_solve = &(_apps[i]->getExecutioner()->fixedPointSolve());
1223  if (fixed_point_solve)
1224  fixed_point_solve->allocateStorage(false);
1225 
1226  // Transform the app mesh if requested
1227  if (_run_in_position)
1228  {
1229  if (usingPositions())
1230  app->getExecutioner()->feProblem().coordTransform().transformMesh(
1231  app->getExecutioner()->feProblem().mesh(), _positions[_first_local_app + i]);
1232  else
1233  app->getExecutioner()->feProblem().coordTransform().transformMesh(
1234  app->getExecutioner()->feProblem().mesh(), Point(0, 0, 0));
1235  }
1236 }
1237 
1238 std::vector<std::string>
1239 MultiApp::getCommandLineArgs(const unsigned int local_app)
1240 {
1241  const auto cla = cliArgs();
1242  auto cli_args_param = _cli_args_param;
1243  std::string combined_args;
1244 
1245  // Single set of args from cliArgs() to be provided to all apps
1246  if (cla.size() == 1)
1247  combined_args = cla[0];
1248  // Single "cli_args_files" file to be provided to all apps
1249  else if (_cli_args_from_file.size() == 1)
1250  {
1251  cli_args_param = "cli_args_files";
1252  combined_args = _cli_args_from_file[0];
1253  }
1254  // Unique set of args from cliArgs() to be provided to each app
1255  else if (cla.size())
1256  combined_args = cla[local_app + _first_local_app];
1257  // Unique set of args from "cli_args_files" to be provided to all apps
1258  else
1259  {
1260  cli_args_param = "cli_args_files";
1261  combined_args = _cli_args_from_file[local_app + _first_local_app];
1262  }
1263 
1264  // Remove all of the beginning and end whitespace so we can recognize truly empty
1265  combined_args = MooseUtils::trim(combined_args);
1266 
1267  // MooseUtils::split will return a single empty entry if there is nothing,
1268  // so exit early if we have nothing
1269  if (combined_args.empty())
1270  return {};
1271 
1272  // Split the argument into a vector of arguments, and make sure
1273  // that we don't have any empty arguments
1274  const auto args = MooseUtils::split(combined_args, ";");
1275  for (const auto & arg : args)
1276  {
1277  if (arg.empty())
1278  {
1279  const auto error = "An empty MultiApp command line argument was provided. Your "
1280  "combined command line string has a ';' with no argument after it.";
1281  if (cli_args_param)
1282  paramError(*cli_args_param, error);
1283  else
1284  mooseError(error);
1285  }
1286  }
1287 
1288  return args;
1289 }
1290 
1293  processor_id_type nprocs,
1294  dof_id_type napps,
1295  processor_id_type min_app_procs,
1296  processor_id_type max_app_procs,
1297  bool batch_mode)
1298 {
1299  if (min_app_procs > nprocs)
1300  mooseError("minimum number of procs per app is higher than the available number of procs");
1301  else if (min_app_procs > max_app_procs)
1302  mooseError("minimum number of procs per app must be lower than the max procs per app");
1303 
1304  mooseAssert(rank < nprocs, "rank must be smaller than the number of procs");
1305 
1306  // A "slot" is a group of procs/ranks that are grouped together to run a
1307  // single (sub)app/sim in parallel.
1308 
1309  const processor_id_type slot_size =
1310  std::max(std::min(cast_int<processor_id_type>(nprocs / napps), max_app_procs), min_app_procs);
1311  const processor_id_type nslots = std::min(
1312  nprocs / slot_size,
1313  cast_int<processor_id_type>(std::min(
1314  static_cast<dof_id_type>(std::numeric_limits<processor_id_type>::max()), napps)));
1315  mooseAssert(nprocs >= (nslots * slot_size),
1316  "Ensure that leftover procs is represented by an unsigned type");
1317  const processor_id_type leftover_procs = nprocs - nslots * slot_size;
1318  const dof_id_type apps_per_slot = napps / nslots;
1319  const dof_id_type leftover_apps = napps % nslots;
1320 
1321  std::vector<int> slot_for_rank(nprocs);
1322  processor_id_type slot = 0;
1323  processor_id_type procs_in_slot = 0;
1324  for (processor_id_type rankiter = 0; rankiter <= rank; rankiter++)
1325  {
1326  if (slot < nslots)
1327  slot_for_rank[rankiter] = cast_int<int>(slot);
1328  else
1329  slot_for_rank[rankiter] = -1;
1330  procs_in_slot++;
1331  // this slot keeps growing until we reach slot size plus possibly an extra
1332  // proc if there were any leftover from the slotization of nprocs - this
1333  // must also make sure we don't go over max app procs.
1334  if (procs_in_slot == slot_size + 1 * (slot < leftover_procs && slot_size < max_app_procs))
1335  {
1336  procs_in_slot = 0;
1337  slot++;
1338  }
1339  }
1340 
1341  if (slot_for_rank[rank] < 0)
1342  // ranks assigned a negative slot don't have any apps running on them.
1343  return {0, 0, 0, 0, false, 0};
1344  const processor_id_type slot_num = cast_int<processor_id_type>(slot_for_rank[rank]);
1345 
1346  const bool is_first_local_rank = rank == 0 || (slot_for_rank[rank - 1] != slot_for_rank[rank]);
1347  const dof_id_type n_local_apps = apps_per_slot + 1 * (slot_num < leftover_apps);
1348 
1349  processor_id_type my_first_rank = 0;
1350  for (processor_id_type rankiter = rank; rankiter > 0; rankiter--)
1351  if (slot_for_rank[rank] != slot_for_rank[rankiter])
1352  {
1353  my_first_rank = cast_int<processor_id_type>(slot_for_rank[rankiter + 1]);
1354  break;
1355  }
1356 
1357  dof_id_type app_index = 0;
1358  for (processor_id_type slot = 0; slot < slot_num; slot++)
1359  {
1360  const dof_id_type num_slot_apps = apps_per_slot + 1 * (slot < leftover_apps);
1361  app_index += num_slot_apps;
1362  }
1363 
1364  if (batch_mode)
1365  return {n_local_apps, app_index, 1, slot_num, is_first_local_rank, my_first_rank};
1366  return {n_local_apps, app_index, n_local_apps, app_index, is_first_local_rank, my_first_rank};
1367 }
1368 
1369 void
1371 {
1372  int ierr;
1373 
1374  ierr = MPI_Comm_size(_communicator.get(), &_orig_num_procs);
1375  mooseCheckMPIErr(ierr);
1376  ierr = MPI_Comm_rank(_communicator.get(), &_orig_rank);
1377  mooseCheckMPIErr(ierr);
1378 
1379 #ifdef LIBMESH_HAVE_SYS_UTSNAME_H
1380  struct utsname sysInfo;
1381  uname(&sysInfo);
1382  _node_name = sysInfo.nodename;
1383 #else
1384  _node_name = "Unknown";
1385 #endif
1386 
1387  int rank;
1388  ierr = MPI_Comm_rank(_communicator.get(), &rank);
1389  mooseCheckMPIErr(ierr);
1390 
1393 
1396  mooseError("Internal error, a processor has an undefined app.");
1397 
1398  if (_has_an_app)
1399  {
1401  ierr = MPI_Comm_rank(_my_comm, &_my_rank);
1402  mooseCheckMPIErr(ierr);
1403  }
1404  else
1405  {
1406  _communicator.split(MPI_UNDEFINED, rank, _my_communicator);
1407  _my_rank = 0;
1408  }
1409 }
1410 
1411 unsigned int
1412 MultiApp::globalAppToLocal(unsigned int global_app)
1413 {
1414  if (global_app >= _first_local_app && global_app <= _first_local_app + (_my_num_apps - 1))
1415  return global_app - _first_local_app;
1416 
1417  std::stringstream ss;
1418  ss << "Requesting app " << global_app << ", but processor " << processor_id() << " ";
1419  if (_my_num_apps == 0)
1420  ss << "does not own any apps";
1421  else if (_my_num_apps == 1)
1422  ss << "owns app " << _first_local_app;
1423  else
1424  ss << "owns apps " << _first_local_app << "-" << _first_local_app + (_my_num_apps - 1);
1425  ss << ".";
1426  mooseError("Invalid global_app!\n", ss.str());
1427  return 0;
1428 }
1429 
1430 void
1432 {
1433 }
1434 
1435 void
1437 {
1438  _associated_transfers.push_back(&transfer);
1439 }
1440 
1441 void
1443 {
1444  for (unsigned int i = 0; i < _my_num_apps; ++i)
1446 }
1447 
1448 std::vector<std::string>
1450 {
1451  // So that we can error out with paramError("cli_args", ...);
1452  _cli_args_param = "cli_args";
1453  return std::vector<std::string>(_cli_args.begin(), _cli_args.end());
1454 }
1455 
1456 void
1458 {
1459  const std::string multiapp_name =
1461  _apps[index]->setOutputFileBase(_app.getOutputFileBase() + "_" + multiapp_name);
1462 }
1463 
1464 std::string
1465 MultiApp::getMultiAppName(const std::string & base_name, dof_id_type index, dof_id_type total)
1466 {
1467  std::ostringstream multiapp_name;
1468  multiapp_name << base_name << std::setw(std::ceil(std::log10(total))) << std::setprecision(0)
1469  << std::setfill('0') << std::right << index;
1470  return multiapp_name.str();
1471 }
1472 
1473 const Point &
1474 MultiApp::position(unsigned int app) const
1475 {
1476  // If we're not using positions, it won't have changed
1477  if (_positions_objs.empty())
1478  return _positions[app];
1479  else
1480  // Find which Positions object is specifying it, and query a potentially updated value
1481  return _positions_objs[app]->getPosition(app - _positions_index_offsets[app], false);
1482 }
1483 
1484 void
1485 dataStore(std::ostream & stream, SubAppBackups & backups, void * context)
1486 {
1487  MultiApp * multi_app = static_cast<MultiApp *>(context);
1488  mooseAssert(multi_app, "Not set");
1489 
1490  multi_app->backup();
1491 
1492  dataStore(stream, static_cast<std::vector<std::unique_ptr<Backup>> &>(backups), nullptr);
1493 }
1494 
1495 void
1496 dataLoad(std::istream & stream, SubAppBackups & backups, void * context)
1497 {
1498  MultiApp * multi_app = static_cast<MultiApp *>(context);
1499  mooseAssert(multi_app, "Not set");
1500 
1501  dataLoad(stream, static_cast<std::vector<std::unique_ptr<Backup>> &>(backups), nullptr);
1502 
1503  multi_app->restore();
1504 }
bool isRegistered(const std::string &app_name) const
Returns a Boolean indicating whether an application type has been registered.
Definition: AppFactory.h:118
void keepSolutionDuringRestore(bool keep_solution_during_restore)
Preserve the solution from the previous simulation, and it is used as an initial guess for the next r...
Definition: MultiApp.C:861
bool hasLocalApp(unsigned int global_app) const
Whether or not the given global app number is on this processor.
Definition: MultiApp.C:1039
std::vector< unsigned int > _reset_apps
The apps to be reset.
Definition: MultiApp.h:571
bool needsRestoration()
Whether or not this MultiApp should be restored at the beginning of each Picard iteration.
Definition: MultiApp.h:210
virtual libMesh::System & getSystem(const std::string &var_name) override
Returns the equation system containing the variable provided.
A MultiMooseEnum object to hold "execute_on" flags.
Definition: ExecFlagEnum.h:21
A class for creating restricted objects.
Definition: Restartable.h:28
MultiApp(const InputParameters &parameters)
Definition: MultiApp.C:273
std::vector< libMesh::BoundingBox > _bounding_box
This multi-app&#39;s bounding box.
Definition: MultiApp.h:547
void addDeprecatedParam(const std::string &name, const T &value, const std::string &doc_string, const std::string &deprecation_message)
std::vector< const Positions * > _positions_objs
The positions of all of the apps, using the Positions system.
Definition: MultiApp.h:490
std::shared_ptr< DisplacedProblem > displaced_problem
const unsigned int invalid_uint
void mooseDeprecated(Args &&... args) const
virtual void restore(bool force=true)
Restore the state of every Sub App.
Definition: MultiApp.C:762
virtual void backup()
Save off the state of every Sub App.
Definition: MultiApp.C:747
bool verboseMultiApps() const
Whether or not to use verbose printing for MultiApps.
NumericVector< Number > & solution()
Definition: SystemBase.h:195
const bool _use_positions
Toggle use of "positions".
Definition: MultiApp.h:496
void setDocString(const std::string &name, const std::string &doc)
Set the doc string of a parameter.
void addPrivateParam(const std::string &name, const T &value)
These method add a parameter to the InputParameters object which can be retrieved like any other para...
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
Definition: FEProblem.h:20
const std::vector< CLIArgString > & _cli_args
CommandLine arguments (controllable!)
Definition: MultiApp.h:592
std::vector< unsigned int > _npositions_inputfile
Number of positions for each input file.
Definition: MultiApp.h:505
void dataLoad(std::istream &stream, SubAppBackups &backups, void *context)
Definition: MultiApp.C:1496
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
void setupPositions()
Called just after construction to allow derived classes to set _positions and create sub-apps accordi...
Definition: MultiApp.C:377
std::shared_ptr< CommandLine > commandLine() const
Get the command line.
Definition: MooseApp.h:451
std::vector< unsigned int > _positions_index_offsets
The offsets, in case multiple Positions objects are specified.
Definition: MultiApp.h:492
const std::vector< Point > getDataAsPoints() const
Get the data in Point format.
Real _move_time
The time at which to move apps.
Definition: MultiApp.h:577
MooseAppPtr createShared(const std::string &app_type, const std::string &name, InputParameters parameters, MPI_Comm COMM_WORLD_IN)
Build an application object (must be registered)
Definition: AppFactory.C:107
const ExecFlagType & getCurrentExecuteOnFlag() const
Return/set the current execution flag.
Real appPostprocessorValue(unsigned int app, const std::string &name)
Get a Postprocessor value for a specified global app.
Definition: MultiApp.C:1018
int _orig_rank
The mpi "rank" of this processor in the original communicator.
Definition: MultiApp.h:532
LocalRankConfig _rank_config
The app configuration resulting from calling init.
Definition: MultiApp.h:613
std::optional< std::string > _cli_args_param
The parameter that was used to set the command line args, if any.
Definition: MultiApp.h:633
std::string getOutputFileBase(bool for_non_moose_build_output=false) const
Get the output file base name.
Definition: MooseApp.C:1599
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:1122
std::vector< std::shared_ptr< MooseApp > > _apps
Pointers to each of the Apps.
Definition: MultiApp.h:541
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
dof_id_type first_local_app_index
The (global) index of the first local app for this rank.
Definition: MultiApp.h:64
FEProblemBase & feProblem()
Return a reference to this Executioner&#39;s FEProblemBase instance.
Definition: Executioner.C:112
unsigned int multiAppLevel() const
The MultiApp Level.
Definition: MooseApp.h:836
virtual void parentOutputPositionChanged()
For apps outputting in position we need to change their output positions if their parent app moves...
Definition: MultiApp.C:1096
MeshBase & mesh
std::vector< Point > _move_positions
The new positions for the apps to be moved.
Definition: MultiApp.h:583
Base class for MOOSE-based applications.
Definition: MooseApp.h:85
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
void dataStore(std::ostream &stream, SubAppBackups &backups, void *context)
Definition: MultiApp.C:1485
static constexpr std::size_t dim
This is the dimension of all vector and tensor datastructures used in MOOSE.
Definition: Moose.h:151
void addAvailableFlags(const ExecFlagType &flag, Args... flags)
Add additional execute_on flags to the list of possible flags.
Definition: ExecFlagEnum.h:82
const PerfID _restore_timer
Definition: MultiApp.h:628
virtual std::unique_ptr< NumericVector< Number > > clone() const =0
const Parallel::Communicator & _communicator
Real _inflation
Relative bounding box inflation.
Definition: MultiApp.h:550
FEProblemBase & _fe_problem
The FEProblemBase this MultiApp is part of.
Definition: MultiApp.h:482
bool isRestarting() const
Whether or not this is a "restart" calculation.
Definition: MooseApp.C:1737
const Positions & getPositionsObject(const std::string &name) const
Get the Positions object by its name.
virtual std::vector< std::string > getCommandLineArgs(const unsigned int local_app)
Definition: MultiApp.C:1239
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
processor_id_type _min_procs_per_app
Minimum number of processors to give to each app.
Definition: MultiApp.h:559
virtual const std::string & name() const
Get the name of the class.
Definition: MooseBase.h:57
int _orig_num_procs
The number of processors in the original comm.
Definition: MultiApp.h:529
void mooseWarning(Args &&... args) const
Emits a warning prefixed with object name and type.
MooseApp & getMooseApp() const
Get the MooseApp this class is associated with.
Definition: MooseBase.h:45
void addRequiredParam(const std::string &name, const std::string &doc_string)
This method adds a parameter and documentation string to the InputParameters object that will be extr...
const PerfID _backup_timer
Definition: MultiApp.h:627
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:1126
std::vector< Real > _reset_times
The times at which to reset apps.
Definition: MultiApp.h:568
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
virtual void preTransfer(Real dt, Real target_time)
Gets called just before transfers are done to the MultiApp (Which is just before the MultiApp is solv...
Definition: MultiApp.C:657
void registerBase(const std::string &value)
This method must be called from every base "Moose System" to create linkage with the Action System...
void createApps()
Create the provided number of apps.
Definition: MultiApp.C:388
virtual libMesh::BoundingBox getBoundingBox(unsigned int app, bool displaced_mesh, const MultiAppCoordTransform *coord_transform=nullptr)
Get the BoundingBox for the mesh associated with app The bounding box will be shifted to be in the co...
Definition: MultiApp.C:911
uint8_t processor_id_type
bool isParamSetByAddParam(const std::string &name) const
Returns whether or not the parameter was set due to addParam.
processor_id_type n_processors() const
const bool & _wait_for_first_app_init
Whether to create the first app on rank 0 while all other MPI ranks are idle.
Definition: MultiApp.h:502
const auto & registeredObjects() const
Returns a reference to the map from names to AppFactoryBuildInfo pointers.
Definition: AppFactory.h:113
static void transformBoundingBox(libMesh::BoundingBox &box, const MultiAppCoordTransform &transform)
Transform a bounding box according to the transformations in the provided coordinate transformation o...
Definition: MultiApp.C:871
virtual libMesh::NumericVector< libMesh::Number > & appTransferVector(unsigned int app, std::string var_name)
Get the vector to transfer to for this MultiApp.
Definition: MultiApp.C:1027
bool _keep_solution_during_restore
Flag indicates if or not restart from the latest solution.
Definition: MultiApp.h:598
void deprecateParam(const std::string &old_name, const std::string &new_name, const std::string &removal_date)
Every object that can be built by the factory should be derived from this class.
Definition: MooseObject.h:28
std::map< std::string, unsigned int > getFileNumbers()
Extracts the file numbers from the output objects.
processor_id_type _max_procs_per_app
Maximum number of processors to give to each app.
Definition: MultiApp.h:556
virtual std::vector< std::string > cliArgs() const
function that provides cli_args to subapps
Definition: MultiApp.C:1449
const ExecFlagType EXEC_TIMESTEP_BEGIN
Definition: Moose.C:34
virtual void fillPositions()
must fill in _positions with the positions of the sub-aps
Definition: MultiApp.C:544
const ExecFlagType EXEC_PRE_MULTIAPP_SETUP
Definition: Moose.C:47
bool _move_happened
Whether or not the move has happened.
Definition: MultiApp.h:586
std::vector< MultiAppTransfer * > _associated_transfers
Transfers associated with this multiapp.
Definition: MultiApp.h:616
Helper class for holding Sub-app backups.
Definition: MultiApp.h:100
const PerfID _reset_timer
Definition: MultiApp.h:629
bool checkFileReadable(const std::string &filename, bool check_line_endings=false, bool throw_on_unreadable=true, bool check_for_git_lfs_pointer=true)
Checks to see if a file is readable (exists and permissions)
Definition: MooseUtils.C:250
std::string trim(const std::string &str, const std::string &white_space=" \\\)
Standard scripting language trim function.
std::vector< std::unique_ptr< NumericVector< Real > > > _end_aux_solutions
The auxiliary solution from the end of the previous solve, this is cloned from the auxiliary solution...
Definition: MultiApp.h:610
std::string _app_type
The type of application to build.
Definition: MultiApp.h:485
std::unique_ptr< NumericVector< Number > > solution
MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and s...
Definition: MooseMesh.h:88
void split(int color, int key, Communicator &target) const
FEProblemBase & appProblemBase(unsigned int app)
Get the FEProblemBase for the global app desired.
Definition: MultiApp.C:985
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition: MooseEnum.h:33
PetscErrorCode PetscInt const PetscInt IS * is
std::vector< unsigned int > _move_apps
The apps to be moved.
Definition: MultiApp.h:580
Executioners are objects that do the actual work of solving your problem.
Definition: Executioner.h:30
Base class for transient executioners that use a FixedPointSolve solve object for multiapp-main app i...
Definition: TransientBase.h:26
MooseApp & _app
The MOOSE application this is associated with.
Definition: MooseBase.h:84
void paramError(const std::string &param, Args... args) const
Emits an error prefixed with the file and line number of the given param (from the input file) along ...
void read()
Perform the actual data reading.
const std::vector< Point > & getPositions(bool initial) const
{ Getters for the positions vector for the desired dimension 1D will be the only one guaranteed to su...
Definition: Positions.C:116
void buildComm()
Create an MPI communicator suitable for each app.
Definition: MultiApp.C:1370
virtual void resetApp(unsigned int global_app, Real time=0.0)
"Reset" the App corresponding to the global App number passed in.
Definition: MultiApp.C:1056
std::string stringify(const T &t)
conversion to string
Definition: Conversion.h:64
AuxiliarySystem & getAuxiliarySystem()
static InputParameters validParams()
const std::string _name
The name of this class.
Definition: MooseBase.h:90
bool isFirstLocalRank() const
Definition: MultiApp.C:1033
Interface for objects interacting with the PerfGraph.
const PostprocessorValue & getPostprocessorValueByName(const PostprocessorName &name, std::size_t t_index=0) const
Get a read-only reference to the value associated with a Postprocessor that exists.
unsigned int _total_num_apps
The total number of apps to simulate.
Definition: MultiApp.h:511
void skipCoordinateCollapsing(bool skip_coordinate_collapsing)
set whether coordinate collapsing operations should be skipped
LocalRankConfig rankConfig(processor_id_type rank, processor_id_type nprocs, dof_id_type napps, processor_id_type min_app_procs, processor_id_type max_app_procs, bool batch_mode)
Returns app partitioning information relevant to the given rank for a multiapp scenario with the give...
Definition: MultiApp.C:1292
Executioner * getExecutioner() const
Retrieve the Executioner for this App.
Definition: MooseApp.C:2047
void broadcast(T &data, const unsigned int root_id=0, const bool identical_sizes=false) const
Point getOutputPosition() const
Get the output position.
Definition: MooseApp.h:297
unsigned int _my_num_apps
The number of apps this object is involved in simulating.
Definition: MultiApp.h:514
static std::string getMultiAppName(const std::string &base_name, dof_id_type index, dof_id_type total)
Helper for constructing the name of the multiapp.
Definition: MultiApp.C:1465
std::string _node_name
Node Name.
Definition: MultiApp.h:535
static AppFactory & instance()
Get the instance of the AppFactory.
Definition: AppFactory.C:18
bool _has_an_app
Whether or not this processor as an App at all
Definition: MultiApp.h:589
std::vector< std::unique_ptr< libMesh::NumericVector< Real > > > _end_solutions
The solution from the end of the previous solve, this is cloned from the Nonlinear solution during re...
Definition: MultiApp.h:607
libMesh::Parallel::Communicator _my_communicator
The communicator object that holds the MPI_Comm that we&#39;re going to use.
Definition: MultiApp.h:523
void createApp(unsigned int i, Real start_time)
Helper function for creating an App instance.
Definition: MultiApp.C:1104
bool isParamSetByUser(const std::string &name) const
Method returns true if the parameter was by the user.
bool usingPositions() const
Whether or not this MultiApp is using positions or its own way for constructing sub-apps.
Definition: MultiApp.h:363
const PerfID _init_timer
Definition: MultiApp.h:626
unsigned int _first_local_app
The number of the first app on this processor.
Definition: MultiApp.h:517
void addAssociatedTransfer(MultiAppTransfer &transfer)
Add a transfer that is associated with this multiapp.
Definition: MultiApp.C:1436
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
virtual std::shared_ptr< const DisplacedProblem > getDisplacedProblem() const
MooseApp * localApp(unsigned int local_app)
Get the local MooseApp object.
Definition: MultiApp.C:1049
virtual void initialSetup() override
Method to be called in main-app initial setup for create sub-apps if using positions is false...
Definition: MultiApp.C:438
Utility class for reading delimited data (e.g., CSV data).
Base class for all MultiAppTransfer objects.
bool is_first_local_rank
This is true if this rank is the primary/zero rank for a (sub)app slot.
Definition: MultiApp.h:71
FEProblem & appProblem(unsigned int app)
Get the FEProblem for the global app is part of.
Definition: MultiApp.C:996
IntRange< T > make_range(T beg, T end)
SubAppBackups & _sub_app_backups
The cached subapp backups (passed from the parent app)
Definition: MultiApp.h:622
virtual MooseMesh & mesh() override
virtual void postExecute()
Method called at the end of the simulation (after finalize).
Definition: MultiApp.C:735
bool _keep_aux_solution_during_restore
Flag indicates if or not restart the auxiliary system from the latest auxiliary solution.
Definition: MultiApp.h:601
bool _output_in_position
Whether or not to move the output of the MultiApp into position.
Definition: MultiApp.h:562
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type.
const InputParameters & _pars
Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.
std::vector< Point > _positions
The positions of all of the apps, using input constant vectors (to be deprecated) ...
Definition: MultiApp.h:488
const InputParameters & parameters() const
Get the parameters of the object.
virtual void finalize()
Method called towards the end of the simulation to execute on final.
Definition: MultiApp.C:722
void readCommandLineArguments()
Fill command line arguments for sub apps.
Definition: MultiApp.C:447
int _my_rank
The mpi "rank" of this processor in the sub communicator.
Definition: MultiApp.h:538
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...
Moose::CoordinateSystemType getCoordSystem(SubdomainID sid) const
Definition: SubProblem.C:1279
dof_id_type num_local_apps
The number of (sub)apps that should/will be run locally on this rank.
Definition: MultiApp.h:58
virtual void createLocalApp(const unsigned int i)
Create the i-th local app.
Definition: MultiApp.C:432
void addRangeCheckedParam(const std::string &name, const T &value, const std::string &parsed_function, const std::string &doc_string)
std::vector< FileName > _input_files
The input file for each app&#39;s simulation.
Definition: MultiApp.h:499
Holds app partitioning information relevant to the a particular rank for a multiapp scenario...
Definition: MultiApp.h:46
virtual void preRunInputFile()
call back executed right before app->runInputFile()
Definition: MultiApp.C:1431
const ConsoleStream _console
An instance of helper class to write streams to the Console objects.
InputParameters getValidParams(const std::string &name)
Get valid parameters for the object.
Definition: AppFactory.C:31
const UserObject & getUserObjectBase(const std::string &name, const THREAD_ID tid=0) const
Get the user object by its name.
Point _bounding_box_padding
Additional padding added to the bounding box, useful for 1D meshes.
Definition: MultiApp.h:553
const Real _global_time_offset
The offset time so the MultiApp local time relative to the global time.
Definition: MultiApp.h:565
void init(unsigned int num_apps, bool batch_mode=false)
Build communicators and reserve backups.
Definition: MultiApp.C:340
static InputParameters validParams()
Definition: MooseObject.C:25
const MPI_Comm & _orig_comm
The original comm handle.
Definition: MultiApp.h:520
static InputParameters validParams()
Definition: MultiApp.C:50
A MultiApp represents one or more MOOSE applications that are running simultaneously.
Definition: MultiApp.h:112
processor_id_type processor_id() const
void setAppOutputFileBase()
Sets all the app&#39;s output file bases.
Definition: MultiApp.C:1442
bool isRecovering() const
Whether or not this is a "recover" calculation.
Definition: MooseApp.C:1731
auto min(const L &left, const R &right)
MPI_Comm & _my_comm
The MPI communicator this object is going to use.
Definition: MultiApp.h:526
const ExecFlagType EXEC_FINAL
Definition: Moose.C:39
void declareControllable(const std::string &name, std::set< ExecFlagType > execute_flags={})
Declare the given parameters as controllable.
const bool _run_in_position
Whether to run the child apps with their meshes transformed with the coordinate transforms.
Definition: MultiApp.h:619
virtual void moveApp(unsigned int global_app, Point p)
Move the global_app to Point p.
Definition: MultiApp.C:1077
void ErrorVector unsigned int
virtual Executioner * getExecutioner(unsigned int app)
Definition: MultiApp.C:713
auto index_range(const T &sizable)
Base class for user-specific data.
Definition: UserObject.h:39
const Point & position(unsigned int app) const
The physical position of a global App number.
Definition: MultiApp.C:1474
OutputWarehouse & getOutputWarehouse()
Get the OutputWarehouse objects.
Definition: MooseApp.C:2343
std::vector< std::string > _cli_args_from_file
CommandLine arguments from files.
Definition: MultiApp.h:595
const UserObject & appUserObjectBase(unsigned int app, const std::string &name)
Get a UserObject base for a specific global app.
Definition: MultiApp.C:1009
const ExecFlagType EXEC_POST_ADAPTIVITY
Definition: Moose.C:51
uint8_t dof_id_type
unsigned int globalAppToLocal(unsigned int global_app)
Map a global App number to the local number.
Definition: MultiApp.C:1412
This class contains transformation information that only exists in a context in which there are multi...
void dynamicAppRegistration(const std::string &app_name, std::string library_path, const std::string &library_name, bool lib_load_deps)
Definition: MooseApp.C:2515
void addParamNamesToGroup(const std::string &space_delim_names, const std::string group_name)
This method takes a space delimited list of parameter names and adds them to the specified group name...
std::vector< bool > _reset_happened
Whether or not apps have been reset at each time.
Definition: MultiApp.h:574
bool isParamValid(const std::string &name) const
This method returns parameters that have been initialized in one fashion or another, i.e.
const ExecFlagType EXEC_INITIAL
Definition: Moose.C:28
std::vector< bool > _has_bounding_box
Flag if this multi-app computed its bounding box (valid only for non-displaced meshes) ...
Definition: MultiApp.h:544