#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. More...

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

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)

virtual void	backup ()

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

MooseApp &	getMooseApp () const

const std::string &	type () const

virtual const std::string &	name () const

std::string	typeAndName () const

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

void	callMooseError (std::string msg, const bool with_prefix) const

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

const InputParameters &	parameters () const

MooseObjectName	uniqueName () 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 &nm) const

void	paramError (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

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

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

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

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

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

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

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

void	mooseInfo (Args &&... args) 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. More...

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. More...

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

Public Attributes
const ConsoleStream	_console

Protected Member Functions
std::vector< std::shared_ptr< PODSamplerSolutionTransfer > >	getActiveSolutionTransfers (Transfer::DIRECTION direction)
	Returning pointers to the solution transfers. Used in batch mode. More...

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

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

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

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

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

void	setAppOutputFileBase (unsigned int index)

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)

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 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. More...

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

Sampler &	_sampler
	Sampler to utilize for creating MultiApps. More...

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

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

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::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

const std::string	_type

const std::string	_name

const InputParameters &	_pars

Factory &	_factory

ActionFactory &	_action_factory

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
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. More...

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. More...

template<typename T = SurrogateTrainerBase>
T &	getSurrogateTrainerByName (const UserObjectName &name) const

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

◆ computeResidual()

void PODFullSolveMultiApp::computeResidual ( )

protected

Evaluating the residuals for every tag in the trainer.

Definition at line 101 of file PODFullSolveMultiApp.C.

Referenced by computeResidualBatch(), and solveStep().

 {
   // 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);
   }
 }

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

Referenced by solveStep().

 {
   // 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();
 }

◆ 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 245 of file SamplerFullSolveMultiApp.C.

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

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

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

Referenced by computeResidualBatch().

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

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

Referenced by computeResidualBatch().

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

◆ 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 340 of file SamplerFullSolveMultiApp.C.

 {
   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<>

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

◆ getSurrogateModel() [2/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.

Referenced by SurrogateTrainer::initialize().

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

◆ getSurrogateModelByName() [1/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]);
 }

◆ getSurrogateModelByName() [2/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.

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

 {
   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]);
 }

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

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

inherited

Definition at line 53 of file SurrogateModelInterface.C.

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

◆ getSurrogateTrainerByName() [2/2]

template<typename T >

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

inherited

Definition at line 111 of file SurrogateModelInterface.h.

Referenced by SurrogateTrainerOutput::output().

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

◆ 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 387 of file SamplerFullSolveMultiApp.C.

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

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

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

PODFullSolveMultiApp::_snapshot_generation

bool _snapshot_generation

Switch used to differentiate between snapshot generation and residual computation.

Definition: PODFullSolveMultiApp.h:60

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

◆ 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 77 of file SamplerFullSolveMultiApp.h.

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

◆ _mode

const StochasticTools::MultiAppMode SamplerFullSolveMultiApp::_mode

protectedinherited

The Sup-application solve mode.

Definition at line 74 of file SamplerFullSolveMultiApp.h.

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

◆ _sampler

Sampler& SamplerFullSolveMultiApp::_sampler

protectedinherited

Sampler to utilize for creating MultiApps.

Definition at line 71 of file SamplerFullSolveMultiApp.h.

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

◆ _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().

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

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ PODFullSolveMultiApp()

Member Function Documentation

◆ computeResidual()

◆ computeResidualBatch()

◆ execBatchTransfers()

◆ getActiveResidualTransfers()

◆ getActiveSolutionTransfers()

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

◆ validParams()

Member Data Documentation

◆ _local_batch_app_index

◆ _mode

◆ _sampler

◆ _snapshot_generation

◆ _trainer