#include <SamplerFullSolveMultiApp.h>

Inheritance diagram for SamplerFullSolveMultiApp:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	SamplerFullSolveMultiApp (const InputParameters &parameters)

virtual bool	solveStep (Real dt, Real target_time, bool auto_advance=true) override

virtual void	preTransfer (Real dt, Real target_time) override

virtual void	backup () override
	This method is overridden so that we only store the initial state and not on any other timestep when doing batch-restore.

virtual void	initialSetup () override

virtual void	finalize () override

virtual void	postExecute () override

virtual void	restore (bool force=true) override

virtual void	preExecute ()

void	setupPositions ()

virtual void	createLocalApp (const unsigned int i)

virtual void	incrementTStep (Real)

virtual void	finishStep (bool=false)

bool	needsRestoration ()

virtual Executioner *	getExecutioner (unsigned int app)

virtual libMesh::BoundingBox	getBoundingBox (unsigned int app, bool displaced_mesh, const MultiAppCoordTransform *coord_transform=nullptr)

FEProblemBase &	problemBase ()

FEProblemBase &	appProblemBase (unsigned int app)

FEProblem &	appProblem (unsigned int app)

const UserObject &	appUserObjectBase (unsigned int app, const std::string &name)

Real	appPostprocessorValue (unsigned int app, const std::string &name)

virtual libMesh::NumericVector< libMesh::Number > &	appTransferVector (unsigned int app, std::string var_name)

unsigned int	numGlobalApps () const

unsigned int	numLocalApps ()

unsigned int	firstLocalApp ()

bool	isFirstLocalRank () const

bool	hasApp ()

bool	hasLocalApp (unsigned int global_app) const

MooseApp *	localApp (unsigned int local_app)

const Point &	position (unsigned int app) const

virtual void	resetApp (unsigned int global_app, Real time=0.0)

virtual void	moveApp (unsigned int global_app, Point p)

virtual void	parentOutputPositionChanged ()

MPI_Comm &	comm ()

const Parallel::Communicator &	comm () const

bool	isRootProcessor ()

bool	usingPositions () const

bool	runningInPosition () const

void	addAssociatedTransfer (MultiAppTransfer &transfer)

void	setAppOutputFileBase ()

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

std::shared_ptr< const MooseObject >	getSharedPtr () const

bool	isKokkosObject () const

MooseApp &	getMooseApp () const

const std::string &	type () const

const std::string &	name () const

std::string	typeAndName () const

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

const T &	getParam (const std::string &name) const

std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const

const T *	queryParam (const std::string &name) const

const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const

T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const

bool	isParamValid (const std::string &name) const

bool	isParamSetByUser (const std::string &name) const

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const

void	paramError (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramInfo (const std::string &param, Args... args) const

std::string	messagePrefix (const bool hit_prefix=true) const

std::string	errorPrefix (const std::string &) const

void	mooseError (Args &&... args) const

void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

void	mooseErrorNonPrefixed (Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseDeprecatedNoTrace (Args &&... args) const

void	mooseInfo (Args &&... args) const

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const

std::string	getDataFileName (const std::string &param) const

std::string	getDataFileNameByName (const std::string &relative_path) const

std::string	getDataFilePath (const std::string &relative_path) const

virtual void	timestepSetup ()

virtual void	jacobianSetup ()

virtual void	residualSetup ()

virtual void	subdomainSetup ()

virtual void	customSetup (const ExecFlagType &)

const ExecFlagEnum &	getExecuteOnEnum () const

PerfGraph &	perfGraph ()

processor_id_type	n_processors () const

processor_id_type	processor_id () const

T &	getSampler (const std::string &name)

Sampler &	getSampler (const std::string &name)

T &	getSamplerByName (const SamplerName &name)

Sampler &	getSamplerByName (const SamplerName &name)

Static Public Member Functions
static InputParameters	validParams ()

static std::vector< std::string >	sampledCommandLineArgs (const std::vector< Real > &row, const std::vector< std::string > &full_args_name)
	Helper for inserting row data into commandline arguments Used here and in SamplerTransientMultiApp.

static void	execBatchTransfers (const std::vector< std::shared_ptr< StochasticToolsTransfer > > &transfers, dof_id_type global_row_index, const std::vector< Real > &row_data, Transfer::DIRECTION direction, bool verbose, const ConsoleStream &console)
	Helper for executing transfers when doing batch stochastic simulations.

static void	callMooseError (MooseApp const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node node, const bool show_trace=true)

static void	transformBoundingBox (libMesh::BoundingBox &box, const MultiAppCoordTransform &transform)

Public Attributes
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

Static Public Attributes
static const std::string	type_param

static const std::string	name_param

static const std::string	unique_name_param

static const std::string	app_param

static const std::string	moose_base_param

static const std::string	kokkos_object_param

Protected Member Functions
virtual void	showStatusMessage (unsigned int i) const override
	Override to avoid 'solve converged' message and print when processors are finished.

virtual std::vector< std::string >	getCommandLineArgs (const unsigned int local_app) override
	Override to allow for batch mode to get correct cli_args.

void	setAppOutputFileBase (unsigned int index)

bool	propagateRecoverToSubApps () const override

virtual std::vector< std::string >	cliArgs () const

virtual void	fillPositions ()

void	readCommandLineArguments ()

void	createApp (unsigned int i, Real start_time)

void	buildComm ()

unsigned int	globalAppToLocal (unsigned int global_app)

virtual void	preRunInputFile ()

void	init (unsigned int num_apps, bool batch_mode=false)

void	init (unsigned int num_apps, const LocalRankConfig &config)

void	createApps ()

void	keepSolutionDuringRestore (bool keep_solution_during_restore)

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const

T &	declareRestartableData (const std::string &data_name, Args &&... args)

ManagedValue< T >	declareManagedRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)

const T &	getRestartableData (const std::string &data_name) const

T &	declareRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)

T &	declareRecoverableData (const std::string &data_name, Args &&... args)

T &	declareRestartableDataWithObjectName (const std::string &data_name, const std::string &object_name, Args &&... args)

T &	declareRestartableDataWithObjectNameWithContext (const std::string &data_name, const std::string &object_name, void *context, Args &&... args)

std::string	restartableName (const std::string &data_name) const

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const

std::string	timedSectionName (const std::string &section_name) const

const ReporterContextBase &	getReporterContextBaseByName (const ReporterName &reporter_name) const

const ReporterName &	getReporterName (const std::string &param_name) const

virtual void	addReporterDependencyHelper (const ReporterName &)

const T &	getReporterValue (const std::string &param_name, const std::size_t time_index=0)

const T &	getReporterValue (const std::string &param_name, ReporterMode mode, const std::size_t time_index=0)

const T &	getReporterValue (const std::string &param_name, const std::size_t time_index=0)

const T &	getReporterValue (const std::string &param_name, ReporterMode mode, const std::size_t time_index=0)

const T &	getReporterValueByName (const ReporterName &reporter_name, const std::size_t time_index=0)

const T &	getReporterValueByName (const ReporterName &reporter_name, ReporterMode mode, const std::size_t time_index=0)

const T &	getReporterValueByName (const ReporterName &reporter_name, const std::size_t time_index=0)

const T &	getReporterValueByName (const ReporterName &reporter_name, ReporterMode mode, const std::size_t time_index=0)

bool	hasReporterValue (const std::string &param_name) const

bool	hasReporterValue (const std::string &param_name) const

bool	hasReporterValue (const std::string &param_name) const

bool	hasReporterValue (const std::string &param_name) const

bool	hasReporterValueByName (const ReporterName &reporter_name) const

bool	hasReporterValueByName (const ReporterName &reporter_name) const

bool	hasReporterValueByName (const ReporterName &reporter_name) const

bool	hasReporterValueByName (const ReporterName &reporter_name) const

Static Protected Member Functions
static std::string	getMultiAppName (const std::string &base_name, dof_id_type index, dof_id_type total)

Protected Attributes
Sampler &	_sampler
	Sampler to utilize for creating MultiApps.

const StochasticTools::MultiAppMode	_mode
	The Sup-application solve mode.

dof_id_type	_local_batch_app_index
	Counter for extracting command line arguments in batch mode.

FEProblemBase &	_fe_problem

std::string	_app_type

std::vector< Point >	_positions

std::vector< const Positions * >	_positions_objs

std::vector< unsigned int >	_positions_index_offsets

const bool	_use_positions

std::vector< FileName >	_input_files

const bool &	_wait_for_first_app_init

std::vector< unsigned int >	_npositions_inputfile

std::string	_output_base

unsigned int	_total_num_apps

unsigned int	_my_num_apps

unsigned int	_first_local_app

const MPI_Comm &	_orig_comm

libMesh::Parallel::Communicator	_my_communicator

MPI_Comm &	_my_comm

int	_orig_num_procs

int	_orig_rank

std::string	_node_name

int	_my_rank

std::vector< std::shared_ptr< MooseApp > >	_apps

std::vector< bool >	_has_bounding_box

std::vector< libMesh::BoundingBox >	_bounding_box

Real	_inflation

Point	_bounding_box_padding

processor_id_type	_max_procs_per_app

processor_id_type	_min_procs_per_app

bool	_output_in_position

const Real	_global_time_offset

std::vector< Real >	_reset_times

std::vector< unsigned int >	_reset_apps

std::vector< bool >	_reset_happened

Real	_move_time

std::vector< unsigned int >	_move_apps

std::vector< Point >	_move_positions

bool	_move_happened

bool	_has_an_app

const std::vector< CLIArgString > &	_cli_args

std::vector< std::string >	_cli_args_from_file

bool	_keep_solution_during_restore

bool	_keep_aux_solution_during_restore

const bool	_no_restore

std::vector< std::vector< std::unique_ptr< libMesh::NumericVector< Real > > > >	_end_solutions

std::vector< std::unique_ptr< NumericVector< Real > > >	_end_aux_solutions

LocalRankConfig	_rank_config

std::vector< MultiAppTransfer * >	_associated_transfers

const bool	_run_in_position

SubAppBackups &	_sub_app_backups

const PerfID	_solve_step_timer

const PerfID	_init_timer

const PerfID	_backup_timer

const PerfID	_restore_timer

const PerfID	_reset_timer

const bool &	_enabled

MooseApp &	_app

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

const ExecFlagEnum &	_execute_enum

const ExecFlagType &	_current_execute_flag

MooseApp &	_restartable_app

const std::string	_restartable_system_name

const THREAD_ID	_restartable_tid

const bool	_restartable_read_only

MooseApp &	_pg_moose_app

const std::string	_prefix

const Parallel::Communicator &	_communicator

Private Member Functions
bool	solveStepBatch (Real dt, Real target_time, bool auto_advance=true)
	Helper method for running in mode='batch'.

void	updateRowData (dof_id_type local_index)
	Helper function for updating _row_data and _local_row_index.

std::vector< std::shared_ptr< StochasticToolsTransfer > >	getActiveStochasticToolsTransfers (Transfer::DIRECTION direction)
	Helper for getting StochasticToolsTransfer objects.

RestartableDataValue &	registerRestartableDataOnApp (std::unique_ptr< RestartableDataValue > data, THREAD_ID tid) const

void	registerRestartableNameWithFilterOnApp (const std::string &name, Moose::RESTARTABLE_FILTER filter)

RestartableData< T > &	declareRestartableDataHelper (const std::string &data_name, void *context, Args &&... args) const

bool	reportersAdded () const

void	possiblyCheckHasReporter (const ReporterName &reporter_name, const std::string &param_name="") const

Static Private Member Functions
static const hit::Node *	getHitNode (const InputParameters &params)

static std::string	messagePrefix (const InputParameters &params, const bool hit_prefix)

Private Attributes
bool	_solved_once

dof_id_type	_number_of_sampler_rows

std::vector< Real >	_row_data
	Current row of data updated by updateRowData. Used by transfers and setting command line args.

dof_id_type	_local_row_index = std::numeric_limits<dof_id_type>::max()
	Current local index representing _row_data.

const std::vector< bool > *	_should_run = nullptr
	Reporter value determining whether the sub-app should be run for a certain sample.

const bool	_ignore_diverge

const bool	_update_old_state_when_keeping_solution_during_restore

std::vector< Executioner * >	_executioners

std::optional< std::string >	_cli_args_param

const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

ExecFlagEnum	_empty_execute_enum

const RestartableDataMapName	_metaname

std::string	_restartable_name

const InputParameters &	_si_params

FEProblemBase &	_si_feproblem

THREAD_ID	_si_tid

const InputParameters &	_ri_params

FEProblemBase &	_ri_fe_problem_base

const ReporterData &	_ri_reporter_data

const MooseObject &	_ri_moose_object

Detailed Description

Definition at line 21 of file SamplerFullSolveMultiApp.h.

Constructor & Destructor Documentation

◆ SamplerFullSolveMultiApp()

SamplerFullSolveMultiApp::SamplerFullSolveMultiApp ( const InputParameters & parameters )

Definition at line 54 of file SamplerFullSolveMultiApp.C.

  : FullSolveMultiApp(parameters),
    SamplerInterface(this),
    ReporterInterface(this),
    _sampler(getSampler("sampler")),
    _mode(getParam<MooseEnum>("mode").getEnum<StochasticTools::MultiAppMode>()),
    _local_batch_app_index(0),
    _solved_once(false)
{
  if (getParam<unsigned int>("min_procs_per_app") !=
          _sampler.getParam<unsigned int>("min_procs_per_row") ||
      getParam<unsigned int>("max_procs_per_app") !=
          _sampler.getParam<unsigned int>("max_procs_per_row"))
    paramError("sampler",
               "Sampler and multiapp communicator configuration inconsistent. Please ensure that "
               "'MultiApps/",
               name(),
               "/min(max)_procs_per_app' and 'Samplers/",
               _sampler.name(),
               "/min(max)_procs_per_row' are the same.");
 
  init(_sampler.getNumberOfRows(),
       _sampler.getRankConfig(_mode == StochasticTools::MultiAppMode::BATCH_RESET ||
                              _mode == StochasticTools::MultiAppMode::BATCH_RESTORE));
  _number_of_sampler_rows = _sampler.getNumberOfRows();
 
  if (isParamValid("should_run_reporter") && _mode == StochasticTools::MultiAppMode::NORMAL)
    paramError("should_run_reporter",
               "Conditionally run sampler multiapp only works in batch modes.");
}

Member Function Documentation

◆ backup()

void SamplerFullSolveMultiApp::backup ( )

overridevirtual

This method is overridden so that we only store the initial state and not on any other timestep when doing batch-restore.

Reimplemented from FullSolveMultiApp.

Definition at line 86 of file SamplerFullSolveMultiApp.C.

{
  if (_mode != StochasticTools::MultiAppMode::BATCH_RESTORE)
    FullSolveMultiApp::backup();
}

Referenced by PODFullSolveMultiApp::computeResidualBatch().

◆ execBatchTransfers()

void SamplerFullSolveMultiApp::execBatchTransfers	(	const std::vector< std::shared_ptr< StochasticToolsTransfer > > &	transfers,
		dof_id_type	global_row_index,
		const std::vector< Real > &	row_data,
		Transfer::DIRECTION	direction,
		bool	verbose,
		const ConsoleStream &	console
	)

static

Helper for executing transfers when doing batch stochastic simulations.

Parameters

transfers	A vector of transfers to execute
global_row_index	The global row index of the run
row_data	The current sampler row of data for the transfer to utilize
type	The current execution flag, used for info printing
direction	The direction of the transfer, used for info printing
verbose	Whether or not print information about the transfer
console	The console stream to output to

Definition at line 265 of file SamplerFullSolveMultiApp.C.

{
  if (verbose && transfers.size())
  {
    console << COLOR_CYAN << "\nBatch transfers for row " << global_row_index;
    if (direction == MultiAppTransfer::TO_MULTIAPP)
      console << " To ";
    else if (direction == MultiAppTransfer::FROM_MULTIAPP)
      console << " From ";
    console << "MultiApps" << COLOR_DEFAULT << ":" << std::endl;
 
    console << "Sampler row " << global_row_index << " data: [" << Moose::stringify(row_data) << "]"
            << std::endl;
 
    // Build Table of Transfer Info
    VariadicTable<std::string, std::string, std::string, std::string> table(
        {"Name", "Type", "From", "To"});
    for (const auto & transfer : transfers)
      table.addRow(
          transfer->name(), transfer->type(), transfer->getFromName(), transfer->getToName());
    table.print(console);
  }
 
  for (auto & transfer : transfers)
  {
    transfer->setGlobalRowIndex(global_row_index);
    transfer->setCurrentRow(row_data);
    if (direction == MultiAppTransfer::TO_MULTIAPP)
      transfer->executeToMultiapp();
    else if (direction == MultiAppTransfer::FROM_MULTIAPP)
      transfer->executeFromMultiapp();
  }
 
  if (verbose && transfers.size())
    console << COLOR_CYAN << "Batch transfers for row " << global_row_index << " Are Finished\n"
            << COLOR_DEFAULT << std::endl;
}

Referenced by solveStepBatch(), and SamplerTransientMultiApp::solveStepBatch().

◆ getActiveStochasticToolsTransfers()

std::vector< std::shared_ptr< StochasticToolsTransfer > > SamplerFullSolveMultiApp::getActiveStochasticToolsTransfers ( Transfer::DIRECTION direction )

private

Helper for getting StochasticToolsTransfer objects.

Definition at line 345 of file SamplerFullSolveMultiApp.C.

{
  std::vector<std::shared_ptr<StochasticToolsTransfer>> output;
  const ExecuteMooseObjectWarehouse<Transfer> & warehouse =
      _fe_problem.getMultiAppTransferWarehouse(direction);
  for (std::shared_ptr<Transfer> transfer : warehouse.getActiveObjects())
  {
    auto ptr = std::dynamic_pointer_cast<StochasticToolsTransfer>(transfer);
    if (ptr && ptr->getMultiApp().get() == this)
      output.push_back(ptr);
  }
  return output;
}

Referenced by solveStepBatch().

◆ getCommandLineArgs()

std::vector< std::string > SamplerFullSolveMultiApp::getCommandLineArgs ( const unsigned int local_app )

overrideprotectedvirtual

Override to allow for batch mode to get correct cli_args.

Reimplemented from FullSolveMultiApp.

Definition at line 360 of file SamplerFullSolveMultiApp.C.

{
  if (_mode == StochasticTools::MultiAppMode::BATCH_RESTORE)
    return FullSolveMultiApp::getCommandLineArgs(local_app);
 
  std::vector<std::string> args;
 
  // With multiple processors per app, there are no local rows for non-root processors
  if (isRootProcessor())
  {
    // Since we only store param_names in cli_args, we need to find the values for each param from
    // sampler data and combine them to get full command line option strings.
    updateRowData(_mode == StochasticTools::MultiAppMode::NORMAL ? local_app
                                                                 : _local_batch_app_index);
 
    args = sampledCommandLineArgs(_row_data, FullSolveMultiApp::getCommandLineArgs(local_app));
  }
 
  _my_communicator.broadcast(args);
  return args;
}

◆ preTransfer()

void SamplerFullSolveMultiApp::preTransfer	(	Real	dt,
		Real	target_time
	)

overridevirtual

Reimplemented from FullSolveMultiApp.

Reimplemented in PODFullSolveMultiApp.

Definition at line 93 of file SamplerFullSolveMultiApp.C.

{
  // Logic for calling initial setup again:
  //    1) If and only if not doing batch-reset (solveStepBatch does this at each local row)
  //    2) If the number of rows have changed since the communicator is re-split.
  //    3) If we have already solved and doing "normal" execution, effectively resetting the apps
  bool initial_setup_required = false;
 
  // Reinitialize MultiApp size
  const auto num_rows = _sampler.getNumberOfRows();
  if (num_rows != _number_of_sampler_rows)
  {
    init(num_rows,
         _sampler.getRankConfig(_mode == StochasticTools::MultiAppMode::BATCH_RESET ||
                                _mode == StochasticTools::MultiAppMode::BATCH_RESTORE));
    _number_of_sampler_rows = num_rows;
    _row_data.clear();
    initial_setup_required = _mode != StochasticTools::MultiAppMode::BATCH_RESET;
  }
  else if (_solved_once)
    initial_setup_required = _mode == StochasticTools::MultiAppMode::NORMAL;
 
  // Call initial setup based on the logic above
  if (initial_setup_required)
  {
    initialSetup();
    _solved_once = false;
  }
  // Otherwise we need to restore for batch-restore
  else if (_solved_once && _mode == StochasticTools::MultiAppMode::BATCH_RESTORE)
    restore();
 
  if (isParamValid("should_run_reporter"))
    _should_run = &getReporterValue<std::vector<bool>>("should_run_reporter");
}

Referenced by PODFullSolveMultiApp::preTransfer().

◆ sampledCommandLineArgs()

std::vector< std::string > SamplerFullSolveMultiApp::sampledCommandLineArgs	(	const std::vector< Real > &	row,
		const std::vector< std::string > &	full_args_name
	)

static

Helper for inserting row data into commandline arguments Used here and in SamplerTransientMultiApp.

How it works:

Scalar parameters are done in order of row data: param1;param2;param3 -> param1=row[0] param2=row[1] param3=row[2]
Vector parameters are assigned with brackets: vec_param1[0,1];vec_param2[1,2] -> vec_param1='row[0] row[1]' vec_param2='row[1] row[2]'
Any parameter already with an equal sign is not modified: param1=3.14;param2[0,1,2] -> param1=3.14 param2='row[0] row[1] row[2]'

Definition at line 410 of file SamplerFullSolveMultiApp.C.

{
  std::vector<std::string> args;
 
  // Find parameters that are meant to be assigned by sampler values
  std::vector<std::string> cli_args_name;
  for (const auto & fan : full_args_name)
  {
    // If it has an '=', then it is not meant to be modified
    if (fan.find("=") == std::string::npos)
      cli_args_name.push_back(fan);
    else
      args.push_back(fan);
  }
 
  // Make sure the parameters either all have brackets, or none of them do
  bool has_brackets = false;
  if (cli_args_name.size())
  {
    has_brackets = cli_args_name[0].find("[") != std::string::npos;
    for (unsigned int i = 1; i < cli_args_name.size(); ++i)
      if (has_brackets != (cli_args_name[i].find("[") != std::string::npos))
        ::mooseError("If the bracket is used, it must be provided to every parameter.");
  }
  if (!has_brackets && cli_args_name.size() && cli_args_name.size() != row.size())
    ::mooseError("Number of command line arguments does not match number of sampler columns.");
 
  for (unsigned int i = 0; i < cli_args_name.size(); ++i)
  {
    // Assign bracketed parameters
    if (has_brackets)
    {
      // Split param name and vector assignment: "param[0,(3.14),1]" -> {"param", "0,(3.14),1]"}
      const std::vector<std::string> & vector_param = MooseUtils::split(cli_args_name[i], "[");
      // Get indices of vector: "0,(3.14),1]" -> {"0", "(3.14)", "1"}
      const std::vector<std::string> & index_string =
          MooseUtils::split(vector_param[1].substr(0, vector_param[1].find("]")), ",");
 
      // Loop through indices and assign parameter: param='row[0] 3.14 row[1]'
      std::vector<std::string> values;
      for (const auto & istr : index_string)
      {
        Real value;
 
        // If the value is enclosed in parentheses, then it isn't an index, it's a value
        if (istr.find("(") != std::string::npos)
          value = std::stod(istr.substr(istr.find("(") + 1));
        // Assign the value from row if it is an index
        else
        {
          unsigned int index = MooseUtils::stringToInteger(istr);
          if (index >= row.size())
            ::mooseError("The provided global column index (",
                         index,
                         ") for ",
                         vector_param[0],
                         " is out of bound.");
          value = row[index];
        }
 
        values.push_back(Moose::stringifyExact(value));
      }
 
      // If there is only one value, do not put quotes around it
      if (values.size() == 1)
        args.push_back(vector_param[0] + "=" + values[0]);
      else
        args.push_back(vector_param[0] + "='" + MooseUtils::stringJoin(values) + "'");
    }
    // Assign scalar parameters
    else
      args.push_back(cli_args_name[i] + "=" + Moose::stringifyExact(row[i]));
  }
 
  return args;
}

Referenced by SamplerParameterTransfer::execute(), SamplerParameterTransfer::executeToMultiapp(), getCommandLineArgs(), and SamplerTransientMultiApp::getCommandLineArgs().

◆ showStatusMessage()

void SamplerFullSolveMultiApp::showStatusMessage ( unsigned int i ) const

overrideprotectedvirtual

Override to avoid 'solve converged' message and print when processors are finished.

Reimplemented from FullSolveMultiApp.

Definition at line 310 of file SamplerFullSolveMultiApp.C.

{
  // Local row is the app index if in normal mode, otherwise it's _local_batch_app_index
  const dof_id_type local_row =
      _mode == StochasticTools::MultiAppMode::NORMAL ? (dof_id_type)i : _local_batch_app_index;
  // If the local row is less than the number of local sims, we aren't finished yet
  if (local_row < _rank_config.num_local_sims - 1)
    return;
 
  // Loop through processors to communicate completeness
  for (const auto & pid : make_range(n_processors()))
  {
    // This is what is being sent to trigger completeness
    dof_id_type last_row = _rank_config.is_first_local_rank
                               ? _rank_config.first_local_sim_index + _rank_config.num_local_sims
                               : 0;
    // Cannot send/receive to the same processor, so avoid if root
    if (pid > 0)
    {
      // Send data to root
      if (pid == processor_id())
        _communicator.send(0, last_row);
      // Receive data from source
      else if (processor_id() == 0)
        _communicator.receive(pid, last_row);
    }
 
    // Output the samples that are complete if it's the main processor for the batch
    if (last_row)
      _console << COLOR_CYAN << type() << " [" << name() << "] " << last_row << "/"
               << _number_of_sampler_rows << " samples complete!" << std::endl;
  }
}

◆ solveStep()

bool SamplerFullSolveMultiApp::solveStep	(	Real	dt,
		Real	target_time,
		bool	auto_advance = `true`
	)

overridevirtual

Reimplemented from FullSolveMultiApp.

Reimplemented in PODFullSolveMultiApp.

Definition at line 130 of file SamplerFullSolveMultiApp.C.

{
  TIME_SECTION("solveStep", 3, "Solving SamplerFullSolveMultiApp");
 
  mooseAssert(_my_num_apps, _sampler.getNumberOfLocalRows());
 
  bool last_solve_converged = true;
 
  if (_mode == StochasticTools::MultiAppMode::BATCH_RESET ||
      _mode == StochasticTools::MultiAppMode::BATCH_RESTORE)
    last_solve_converged = solveStepBatch(dt, target_time, auto_advance);
  else
    last_solve_converged = FullSolveMultiApp::solveStep(dt, target_time, auto_advance);
 
  _solved_once = true;
 
  return last_solve_converged;
}

Referenced by PODFullSolveMultiApp::solveStep().

◆ solveStepBatch()

bool SamplerFullSolveMultiApp::solveStepBatch	(	Real	dt,
		Real	target_time,
		bool	auto_advance = `true`
	)

private

Helper method for running in mode='batch'.

Definition at line 150 of file SamplerFullSolveMultiApp.C.

{
  TIME_SECTION("solveStepBatch", 3, "Solving Step Batch For SamplerFullSolveMultiApp");
 
  if (_should_run && _should_run->size() < _sampler.getNumberOfLocalRows())
    paramError("should_run_reporter",
               "Reporter deteriming multiapp run must be of size greater than or equal to the "
               "number of local rows in the sampler, ",
               _should_run->size(),
               " < ",
               _sampler.getNumberOfLocalRows(),
               ".");
 
  // Value to return
  bool last_solve_converged = true;
 
  // List of active relevant Transfer objects
  std::vector<std::shared_ptr<StochasticToolsTransfer>> to_transfers =
      getActiveStochasticToolsTransfers(MultiAppTransfer::TO_MULTIAPP);
  std::vector<std::shared_ptr<StochasticToolsTransfer>> from_transfers =
      getActiveStochasticToolsTransfers(MultiAppTransfer::FROM_MULTIAPP);
 
  // Initialize to/from transfers
  for (auto transfer : to_transfers)
  {
    transfer->setGlobalMultiAppIndex(_rank_config.first_local_app_index);
    transfer->initializeToMultiapp();
  }
  for (auto transfer : from_transfers)
  {
    transfer->setGlobalMultiAppIndex(_rank_config.first_local_app_index);
    transfer->initializeFromMultiapp();
  }
 
  if (!_solved_once && _mode == StochasticTools::MultiAppMode::BATCH_RESTORE)
    FullSolveMultiApp::backup();
 
  // Perform batch MultiApp solves
  _local_batch_app_index = 0;
  for (dof_id_type i = _rank_config.first_local_sim_index;
       i < _rank_config.first_local_sim_index + _rank_config.num_local_sims;
       ++i)
  {
    updateRowData(_local_batch_app_index);
 
    bool run = true;
    if (_should_run)
    {
      if (isRootProcessor())
        run = (*_should_run)[_local_batch_app_index];
      _my_communicator.broadcast(run, 0);
    }
    if (!run)
    {
      _local_batch_app_index++;
      continue;
    }
 
    // Given that we don't initialize in preTransfer for batch-reset mode, we need
    // a different logic for resetting the apps for every sample:
    // - batch-restore: after (re-)initializing the problem, we only need to restore
    //   starting from the second sample
    if (_mode == StochasticTools::MultiAppMode::BATCH_RESTORE)
    {
      if (i != _rank_config.first_local_sim_index)
        restore();
    }
    // - batch-reset: we don't need to initialize for the first sample in the first
    //   solve. After that, we initialize every time. This is mainly to avoid unnecessary
    //   initializations for cases when the multiapp does not need to be executed (conditional runs)
    else
    {
      if (i != _rank_config.first_local_sim_index || _solved_once)
        initialSetup();
    }
 
    execBatchTransfers(to_transfers,
                       i,
                       _row_data,
                       MultiAppTransfer::TO_MULTIAPP,
                       _fe_problem.verboseMultiApps(),
                       _console);
 
    // Set the file base based on the current row
    for (unsigned int ai = 0; ai < _my_num_apps; ++ai)
    {
      const std::string mname = getMultiAppName(name(), i, _number_of_sampler_rows);
      _apps[ai]->setOutputFileBase(_app.getOutputFileBase() + "_" + mname);
    }
 
    const bool curr_last_solve_converged =
        FullSolveMultiApp::solveStep(dt, target_time, auto_advance);
    last_solve_converged = last_solve_converged && curr_last_solve_converged;
 
    execBatchTransfers(from_transfers,
                       i,
                       _row_data,
                       MultiAppTransfer::FROM_MULTIAPP,
                       _fe_problem.verboseMultiApps(),
                       _console);
 
    _local_batch_app_index++;
  }
  _local_batch_app_index = 0;
 
  // Finalize to/from transfers
  for (auto transfer : to_transfers)
    transfer->finalizeToMultiapp();
  for (auto transfer : from_transfers)
    transfer->finalizeFromMultiapp();
 
  return last_solve_converged;
}

Referenced by solveStep().

◆ updateRowData()

void SamplerFullSolveMultiApp::updateRowData ( dof_id_type local_index )

private

Helper function for updating _row_data and _local_row_index.

This allows multiple calls to the same row index

Definition at line 383 of file SamplerFullSolveMultiApp.C.

{
  if (!isRootProcessor())
    return;
 
  mooseAssert(local_index < _sampler.getNumberOfLocalRows(),
              "Local index must be less than number of local rows.");
 
  if (_row_data.empty() ||
      (_local_row_index == _sampler.getNumberOfLocalRows() - 1 && local_index == 0))
  {
    mooseAssert(local_index == 0,
                "The first time calling updateRowData must have a local index of 0.");
    _local_row_index = 0;
    _row_data = _sampler.getNextLocalRow();
  }
  else if (local_index - _local_row_index == 1)
  {
    _local_row_index++;
    _row_data = _sampler.getNextLocalRow();
  }
 
  mooseAssert(local_index == _local_row_index,
              "Local index must be equal or one greater than the index previously called.");
}

Referenced by getCommandLineArgs(), and solveStepBatch().

◆ validParams()

InputParameters SamplerFullSolveMultiApp::validParams ( )

static

Definition at line 20 of file SamplerFullSolveMultiApp.C.

{
  InputParameters params = FullSolveMultiApp::validParams();
  params += SamplerInterface::validParams();
  params += ReporterInterface::validParams();
  params.addClassDescription(
      "Creates a full-solve type sub-application for each row of each Sampler matrix.");
  params.addRequiredParam<SamplerName>("sampler",
                                       "The Sampler object to utilize for creating MultiApps.");
  params.suppressParameter<std::vector<Point>>("positions");
  params.suppressParameter<bool>("output_in_position");
  params.suppressParameter<std::vector<FileName>>("positions_file");
  params.suppressParameter<Real>("move_time");
  params.suppressParameter<std::vector<Point>>("move_positions");
  params.suppressParameter<std::vector<unsigned int>>("move_apps");
  params.set<bool>("use_positions") = false;
 
  MooseEnum modes("normal=0 batch-reset=1 batch-restore=2", "normal");
  params.addParam<MooseEnum>(
      "mode",
      modes,
      "The operation mode, 'normal' creates one sub-application for each row in the Sampler and "
      "'batch-reset' and 'batch-restore' creates N sub-applications, where N is the minimum of "
      "'num_rows' in the Sampler and floor(number of processes / min_procs_per_app). To run "
      "the rows in the Sampler, 'batch-reset' will destroy and re-create sub-apps as needed, "
      "whereas the 'batch-restore' will backup and restore sub-apps to the initial state prior "
      "to execution, without destruction.");
  params.addParam<ReporterName>(
      "should_run_reporter",
      "Vector reporter value determining whether a certain multiapp should be run with this "
      "multiapp. This only works in batch-reset or batch-restore mode.");
  return params;
}