#include <PODFullSolveMultiApp.h>

Inheritance diagram for PODFullSolveMultiApp:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	PODFullSolveMultiApp (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
	Overriding preTransfer to reinit the subappliations if the object needs to be executed twice.

bool	snapshotGeneration ()
	Returning the value of the snapshot generation flag.

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
std::vector< std::shared_ptr< PODSamplerSolutionTransfer > >	getActiveSolutionTransfers (Transfer::DIRECTION direction)
	Returning pointers to the solution transfers. Used in batch mode.

std::vector< std::shared_ptr< PODResidualTransfer > >	getActiveResidualTransfers (Transfer::DIRECTION direction)
	Returning pointers to the solution transfers. Used in batch mode.

void	computeResidual ()
	Evaluating the residuals for every tag in the trainer.

void	computeResidualBatch (Real target_time)
	Evaluating the residuals for every tag in the trainer in batch mode.

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
PODReducedBasisTrainer &	_trainer
	Pointer to the trainer object itself.

bool	_snapshot_generation
	Switch used to differentiate between snapshot generation and residual computation.

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

template<>
SurrogateModel &	getSurrogateModel (const std::string &name) const

template<>
SurrogateTrainerBase &	getSurrogateTrainer (const std::string &name) const

template<>
SurrogateModel &	getSurrogateModelByName (const UserObjectName &name) const

template<>
SurrogateTrainerBase &	getSurrogateTrainerByName (const UserObjectName &name) const


template<typename T = SurrogateModel>
T &	getSurrogateModel (const std::string &name) const
	Get a SurrogateModel/Trainer with a given name.

template<typename T = SurrogateTrainerBase>
T &	getSurrogateTrainer (const std::string &name) const


template<typename T = SurrogateModel>
T &	getSurrogateModelByName (const UserObjectName &name) const
	Get a sampler with a given name.

template<typename T = SurrogateTrainerBase>
T &	getSurrogateTrainerByName (const UserObjectName &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

const InputParameters &	_smi_params
	Parameters of the object with this interface.

FEProblemBase &	_smi_feproblem
	Reference to FEProblemBase instance.

const THREAD_ID	_smi_tid
	Thread ID.

Detailed Description

Definition at line 23 of file PODFullSolveMultiApp.h.

Constructor & Destructor Documentation

◆ PODFullSolveMultiApp()

PODFullSolveMultiApp::PODFullSolveMultiApp ( const InputParameters & parameters )

Definition at line 34 of file PODFullSolveMultiApp.C.

  : SamplerFullSolveMultiApp(parameters),
    SurrogateModelInterface(this),
    _trainer(getSurrogateTrainer<PODReducedBasisTrainer>("trainer_name")),
    _snapshot_generation(true)
{
  if (getParam<unsigned int>("max_procs_per_app") != 1)
    paramError("max_procs_per_app", " does not support more than one processors per subapp!");
 
  if (n_processors() > _sampler.getNumberOfRows())
    mooseError(type(),
               " needs to be run with fewer processors (detected ",
               n_processors(),
               ") than samples (detected ",
               _sampler.getNumberOfRows(),
               ")!");
}

Member Function Documentation

◆ backup()

void SamplerFullSolveMultiApp::backup ( )

overridevirtualinherited

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 computeResidualBatch().

◆ computeResidual()

void PODFullSolveMultiApp::computeResidual ( )

protected

Evaluating the residuals for every tag in the trainer.

Definition at line 101 of file PODFullSolveMultiApp.C.

{
  // Doing the regular computation but instead of solving the subapplication,
  // the residuals for different tags are evaluated.
  if (!_has_an_app)
    return;
 
  Moose::ScopedCommSwapper swapper(_my_comm);
 
  int rank;
  int ierr;
  ierr = MPI_Comm_rank(_communicator.get(), &rank);
  mooseCheckMPIErr(ierr);
 
  // Getting the necessary tag names.
  const std::vector<std::string> & trainer_tags = _trainer.getTagNames();
 
  // Looping over the subapplications and computing residuals.
  for (unsigned int i = 0; i < _my_num_apps; i++)
  {
    // Getting the local problem
    FEProblemBase & problem = _apps[i]->getExecutioner()->feProblem();
 
    // Extracting the TagIDs based on tag names from the current subapp.
    std::set<TagID> tags_to_compute;
    for (auto & tag_name : trainer_tags)
      tags_to_compute.insert(problem.getVectorTagID(tag_name));
 
    problem.setCurrentNonlinearSystem(0);
    problem.computeResidualTags(tags_to_compute);
  }
}

Referenced by computeResidualBatch(), and solveStep().

◆ computeResidualBatch()

void PODFullSolveMultiApp::computeResidualBatch ( Real target_time )

protected

Evaluating the residuals for every tag in the trainer in batch mode.

Definition at line 135 of file PODFullSolveMultiApp.C.

{
  // Getting the overall base size from the trainer.
  dof_id_type base_size = _trainer.getSumBaseSize();
 
  // Distributing the residual evaluation among processes.
  dof_id_type local_base_begin;
  dof_id_type local_base_end;
  dof_id_type n_local_bases;
  MooseUtils::linearPartitionItems(
      base_size, n_processors(), processor_id(), n_local_bases, local_base_begin, local_base_end);
 
  // List of active relevant Transfer objects
  std::vector<std::shared_ptr<PODSamplerSolutionTransfer>> to_transfers =
      getActiveSolutionTransfers(MultiAppTransfer::TO_MULTIAPP);
  std::vector<std::shared_ptr<PODResidualTransfer>> from_transfers =
      getActiveResidualTransfers(MultiAppTransfer::FROM_MULTIAPP);
 
  // Initialize to/from transfers
  for (auto transfer : to_transfers)
    transfer->initializeToMultiapp();
 
  for (auto transfer : from_transfers)
    transfer->initializeFromMultiapp();
 
  if (_mode == StochasticTools::MultiAppMode::BATCH_RESTORE)
    backup();
 
  // Perform batch MultiApp solves
  _local_batch_app_index = 0;
  for (dof_id_type i = local_base_begin; i < local_base_end; ++i)
  {
    for (auto & transfer : to_transfers)
    {
      transfer->setGlobalMultiAppIndex(i);
      transfer->executeToMultiapp();
    }
 
    computeResidual();
 
    for (auto & transfer : from_transfers)
    {
      transfer->setGlobalMultiAppIndex(i);
      transfer->executeFromMultiapp();
    }
 
    if (i < _sampler.getLocalRowEnd() - 1)
    {
      if (_mode == StochasticTools::MultiAppMode::BATCH_RESTORE)
        restore();
      else
      {
        // The app is being reset for the next loop, thus the batch index must be indexed as such
        _local_batch_app_index++;
        resetApp(_local_batch_app_index + i, target_time);
        initialSetup();
      }
    }
  }
 
  // Finalize to/from transfers
  for (auto transfer : to_transfers)
    transfer->finalizeToMultiapp();
  for (auto transfer : from_transfers)
    transfer->finalizeFromMultiapp();
}

Referenced by solveStep().

◆ 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
	)

staticinherited

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 SamplerFullSolveMultiApp::solveStepBatch(), and SamplerTransientMultiApp::solveStepBatch().

◆ getActiveResidualTransfers()

std::vector< std::shared_ptr< PODResidualTransfer > > PODFullSolveMultiApp::getActiveResidualTransfers ( Transfer::DIRECTION direction )

protected

Returning pointers to the solution transfers. Used in batch mode.

Definition at line 218 of file PODFullSolveMultiApp.C.

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

Referenced by computeResidualBatch().

◆ getActiveSolutionTransfers()

std::vector< std::shared_ptr< PODSamplerSolutionTransfer > > PODFullSolveMultiApp::getActiveSolutionTransfers ( Transfer::DIRECTION direction )

protected

Returning pointers to the solution transfers. Used in batch mode.

Definition at line 203 of file PODFullSolveMultiApp.C.

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

Referenced by computeResidualBatch().

◆ getActiveStochasticToolsTransfers()

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

privateinherited

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 SamplerFullSolveMultiApp::solveStepBatch().

◆ getCommandLineArgs()

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

overrideprotectedvirtualinherited

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;
}

◆ getSurrogateModel() [1/2]

template<typename T >

T & SurrogateModelInterface::getSurrogateModel ( const std::string & name ) const

inherited

Get a SurrogateModel/Trainer with a given name.

Parameters

name	The name of the parameter key of the sampler to retrieve

Returns: The sampler with name associated with the parameter 'name'

Definition at line 81 of file SurrogateModelInterface.h.

{
  return getSurrogateModelByName<T>(_smi_params.get<UserObjectName>(name));
}

Referenced by SurrogateTrainer::initialize().

◆ getSurrogateModel() [2/2]

template<>

SurrogateModel & SurrogateModelInterface::getSurrogateModel ( const std::string & name ) const

inherited

Definition at line 46 of file SurrogateModelInterface.C.

{
  return getSurrogateModelByName<SurrogateModel>(_smi_params.get<UserObjectName>(name));
}

◆ getSurrogateModelByName() [1/2]

template<typename T >

T & SurrogateModelInterface::getSurrogateModelByName ( const UserObjectName & name ) const

inherited

Get a sampler with a given name.

Parameters

name	The name of the sampler to retrieve

Returns: The sampler with name 'name'

Definition at line 88 of file SurrogateModelInterface.h.

{
  std::vector<T *> models;
  _smi_feproblem.theWarehouse()
      .query()
      .condition<AttribName>(name)
      .condition<AttribSystem>("SurrogateModel")
      .queryInto(models);
  if (models.empty())
    mooseError("Unable to find a SurrogateModel object of type " + std::string(typeid(T).name()) +
               " with the name '" + name + "'");
  return *(models[0]);
}

Referenced by CrossValidationScores::CrossValidationScores(), EvaluateSurrogate::EvaluateSurrogate(), and InverseMapping::initialSetup().

◆ getSurrogateModelByName() [2/2]

template<>

SurrogateModel & SurrogateModelInterface::getSurrogateModelByName ( const UserObjectName & name ) const

inherited

Definition at line 31 of file SurrogateModelInterface.C.

{
  std::vector<SurrogateModel *> models;
  _smi_feproblem.theWarehouse()
      .query()
      .condition<AttribName>(name)
      .condition<AttribSystem>("SurrogateModel")
      .queryInto(models);
  if (models.empty())
    mooseError("Unable to find a SurrogateModel object with the name '" + name + "'");
  return *(models[0]);
}

◆ getSurrogateTrainer() [1/2]

template<typename T >

T & SurrogateModelInterface::getSurrogateTrainer ( const std::string & name ) const

inherited

Definition at line 104 of file SurrogateModelInterface.h.

{
  return getSurrogateTrainerByName<T>(_smi_params.get<UserObjectName>(name));
}

◆ getSurrogateTrainer() [2/2]

template<>

SurrogateTrainerBase & SurrogateModelInterface::getSurrogateTrainer ( const std::string & name ) const

inherited

Definition at line 60 of file SurrogateModelInterface.C.

{
  return getSurrogateTrainerByName<SurrogateTrainerBase>(_smi_params.get<UserObjectName>(name));
}

◆ getSurrogateTrainerByName() [1/2]

template<typename T >

T & SurrogateModelInterface::getSurrogateTrainerByName ( const UserObjectName & name ) const

inherited

Definition at line 111 of file SurrogateModelInterface.h.

{
  SurrogateTrainerBase * base_ptr =
      &_smi_feproblem.getUserObject<SurrogateTrainerBase>(name, _smi_tid);
  T * obj_ptr = dynamic_cast<T *>(base_ptr);
  if (!obj_ptr)
    mooseError("Failed to find a SurrogateTrainer object of type " + std::string(typeid(T).name()) +
                   " with the name '",
               name,
               "' for the desired type.");
  return *obj_ptr;
}

Referenced by SurrogateTrainerOutput::output().

◆ getSurrogateTrainerByName() [2/2]

template<>

SurrogateTrainerBase & SurrogateModelInterface::getSurrogateTrainerByName ( const UserObjectName & name ) const

inherited

Definition at line 53 of file SurrogateModelInterface.C.

{
  return _smi_feproblem.getUserObject<SurrogateTrainerBase>(name);
}

◆ preTransfer()

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

overridevirtual

Overriding preTransfer to reinit the subappliations if the object needs to be executed twice.

Reimplemented from SamplerFullSolveMultiApp.

Definition at line 53 of file PODFullSolveMultiApp.C.

{
  // Reinitialize the problem only if the snapshot generation part is done.
  if (!_snapshot_generation)
  {
    dof_id_type base_size = _trainer.getSumBaseSize();
    if (base_size < 1)
      mooseError(
          "There are no basis vectors available for residual generation."
          " This indicates that the bases have not been created yet."
          " The most common cause of this error is the wrong setting"
          " of the 'execute_on' flags in the PODFullSolveMultiApp and/or PODReducedBasisTrainer.");
 
    init(base_size,
         _sampler.getRankConfig(_mode == StochasticTools::MultiAppMode::BATCH_RESET ||
                                _mode == StochasticTools::MultiAppMode::BATCH_RESTORE));
 
    initialSetup();
  }
  SamplerFullSolveMultiApp::preTransfer(dt, target_time);
}

◆ sampledCommandLineArgs()

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

staticinherited

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(), SamplerFullSolveMultiApp::getCommandLineArgs(), and SamplerTransientMultiApp::getCommandLineArgs().

◆ showStatusMessage()

void SamplerFullSolveMultiApp::showStatusMessage ( unsigned int i ) const

overrideprotectedvirtualinherited

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;
  }
}

◆ snapshotGeneration()

bool PODFullSolveMultiApp::snapshotGeneration ( )

inline

Returning the value of the snapshot generation flag.

Definition at line 37 of file PODFullSolveMultiApp.h.

37{ return _snapshot_generation; }

◆ solveStep()

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

overridevirtual

Reimplemented from SamplerFullSolveMultiApp.

Definition at line 76 of file PODFullSolveMultiApp.C.

{
 
  bool last_solve_converged = true;
 
  // If snapshot generation phase, solve the subapplications in a regular manner.
  // Otherwise, compute the residuals only.
  if (_snapshot_generation)
  {
    last_solve_converged = SamplerFullSolveMultiApp::solveStep(dt, target_time, auto_advance);
    _snapshot_generation = false;
  }
  else
  {
    if (_mode == StochasticTools::MultiAppMode::BATCH_RESET ||
        _mode == StochasticTools::MultiAppMode::BATCH_RESTORE)
      computeResidualBatch(target_time);
    else
      computeResidual();
  }
 
  return last_solve_converged;
}

◆ solveStepBatch()

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

privateinherited

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 SamplerFullSolveMultiApp::solveStep().

◆ updateRowData()

void SamplerFullSolveMultiApp::updateRowData ( dof_id_type local_index )

privateinherited

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 SamplerFullSolveMultiApp::getCommandLineArgs(), and SamplerFullSolveMultiApp::solveStepBatch().

◆ validParams()

InputParameters PODFullSolveMultiApp::validParams ( )

static

Definition at line 21 of file PODFullSolveMultiApp.C.

{
  InputParameters params = SamplerFullSolveMultiApp::validParams();
  params.addClassDescription(
      "Creates a full-solve type sub-application for each row of a Sampler matrix. "
      "On second call, this object creates residuals for a PODReducedBasisTrainer with given basis "
      "functions.");
  params.addRequiredParam<UserObjectName>(
      "trainer_name", "Trainer object that contains the solutions for different samples.");
 
  return params;
}

Member Data Documentation

◆ _local_batch_app_index

dof_id_type SamplerFullSolveMultiApp::_local_batch_app_index

protectedinherited

Counter for extracting command line arguments in batch mode.

Definition at line 83 of file SamplerFullSolveMultiApp.h.

Referenced by computeResidualBatch(), SamplerFullSolveMultiApp::getCommandLineArgs(), SamplerFullSolveMultiApp::showStatusMessage(), and SamplerFullSolveMultiApp::solveStepBatch().

◆ _local_row_index

dof_id_type SamplerFullSolveMultiApp::_local_row_index = std::numeric_limits<dof_id_type>::max()

privateinherited

Current local index representing _row_data.

Definition at line 115 of file SamplerFullSolveMultiApp.h.

Referenced by SamplerFullSolveMultiApp::updateRowData().

◆ _mode

const StochasticTools::MultiAppMode SamplerFullSolveMultiApp::_mode

protectedinherited

The Sup-application solve mode.

Definition at line 80 of file SamplerFullSolveMultiApp.h.

Referenced by SamplerFullSolveMultiApp::backup(), computeResidualBatch(), SamplerFullSolveMultiApp::getCommandLineArgs(), preTransfer(), SamplerFullSolveMultiApp::preTransfer(), SamplerFullSolveMultiApp::SamplerFullSolveMultiApp(), SamplerFullSolveMultiApp::showStatusMessage(), solveStep(), SamplerFullSolveMultiApp::solveStep(), and SamplerFullSolveMultiApp::solveStepBatch().

◆ _number_of_sampler_rows

dof_id_type SamplerFullSolveMultiApp::_number_of_sampler_rows

privateinherited

Definition at line 110 of file SamplerFullSolveMultiApp.h.

Referenced by SamplerFullSolveMultiApp::preTransfer(), SamplerFullSolveMultiApp::SamplerFullSolveMultiApp(), SamplerFullSolveMultiApp::showStatusMessage(), and SamplerFullSolveMultiApp::solveStepBatch().

◆ _row_data

std::vector<Real> SamplerFullSolveMultiApp::_row_data

privateinherited

Current row of data updated by updateRowData. Used by transfers and setting command line args.

Definition at line 113 of file SamplerFullSolveMultiApp.h.

Referenced by SamplerFullSolveMultiApp::getCommandLineArgs(), SamplerFullSolveMultiApp::preTransfer(), SamplerFullSolveMultiApp::solveStepBatch(), and SamplerFullSolveMultiApp::updateRowData().

◆ _sampler

Sampler& SamplerFullSolveMultiApp::_sampler

protectedinherited

Sampler to utilize for creating MultiApps.

Definition at line 77 of file SamplerFullSolveMultiApp.h.

Referenced by computeResidualBatch(), PODFullSolveMultiApp(), preTransfer(), SamplerFullSolveMultiApp::preTransfer(), SamplerFullSolveMultiApp::SamplerFullSolveMultiApp(), SamplerFullSolveMultiApp::solveStep(), SamplerFullSolveMultiApp::solveStepBatch(), and SamplerFullSolveMultiApp::updateRowData().

◆ _should_run

const std::vector<bool>* SamplerFullSolveMultiApp::_should_run = nullptr

privateinherited

Reporter value determining whether the sub-app should be run for a certain sample.

Definition at line 118 of file SamplerFullSolveMultiApp.h.

Referenced by SamplerFullSolveMultiApp::preTransfer(), and SamplerFullSolveMultiApp::solveStepBatch().

◆ _smi_feproblem

FEProblemBase& SurrogateModelInterface::_smi_feproblem

privateinherited

Reference to FEProblemBase instance.

Definition at line 73 of file SurrogateModelInterface.h.

Referenced by SurrogateModelInterface::getSurrogateModelByName(), and SurrogateModelInterface::getSurrogateTrainerByName().

◆ _smi_params

const InputParameters& SurrogateModelInterface::_smi_params

privateinherited

Parameters of the object with this interface.

Definition at line 70 of file SurrogateModelInterface.h.

Referenced by SurrogateModelInterface::getSurrogateModel(), and SurrogateModelInterface::getSurrogateTrainer().

◆ _smi_tid

const THREAD_ID SurrogateModelInterface::_smi_tid

privateinherited

Thread ID.

Definition at line 76 of file SurrogateModelInterface.h.

Referenced by SurrogateModelInterface::getSurrogateTrainerByName().

◆ _snapshot_generation

bool PODFullSolveMultiApp::_snapshot_generation

protected

Switch used to differentiate between snapshot generation and residual computation.

Residual generation is only possible after the snapshot generation part is complete.

Definition at line 60 of file PODFullSolveMultiApp.h.

Referenced by preTransfer(), snapshotGeneration(), and solveStep().

◆ _solved_once

bool SamplerFullSolveMultiApp::_solved_once

privateinherited

Definition at line 107 of file SamplerFullSolveMultiApp.h.

Referenced by SamplerFullSolveMultiApp::preTransfer(), SamplerFullSolveMultiApp::solveStep(), and SamplerFullSolveMultiApp::solveStepBatch().

◆ _trainer

PODReducedBasisTrainer& PODFullSolveMultiApp::_trainer

protected

Pointer to the trainer object itself.

Definition at line 55 of file PODFullSolveMultiApp.h.

Referenced by computeResidual(), computeResidualBatch(), and preTransfer().

The documentation for this class was generated from the following files:

stochastic_tools/include/multiapps/PODFullSolveMultiApp.h
stochastic_tools/src/multiapps/PODFullSolveMultiApp.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PODFullSolveMultiApp()

Member Function Documentation

◆ backup()

◆ computeResidual()

◆ computeResidualBatch()

◆ execBatchTransfers()

◆ getActiveResidualTransfers()

◆ getActiveSolutionTransfers()

◆ getActiveStochasticToolsTransfers()

◆ getCommandLineArgs()

◆ getSurrogateModel() [1/2]

◆ getSurrogateModel() [2/2]

◆ getSurrogateModelByName() [1/2]

◆ getSurrogateModelByName() [2/2]

◆ getSurrogateTrainer() [1/2]

◆ getSurrogateTrainer() [2/2]

◆ getSurrogateTrainerByName() [1/2]

◆ getSurrogateTrainerByName() [2/2]

◆ preTransfer()

◆ sampledCommandLineArgs()

◆ showStatusMessage()

◆ snapshotGeneration()

◆ solveStep()

◆ solveStepBatch()

◆ updateRowData()

◆ validParams()

Member Data Documentation

◆ _local_batch_app_index

◆ _local_row_index

◆ _mode

◆ _number_of_sampler_rows

◆ _row_data

◆ _sampler

◆ _should_run

◆ _smi_feproblem

◆ _smi_params

◆ _smi_tid

◆ _snapshot_generation

◆ _solved_once

◆ _trainer