SamplerTransientMultiApp Class Reference

#include <SamplerTransientMultiApp.h>

Inheritance diagram for SamplerTransientMultiApp:

Public Member Functions
	SamplerTransientMultiApp (const InputParameters &parameters)
virtual bool	solveStep (Real dt, Real target_time, bool auto_advance=true) override
	Override solveStep to allow for batch execution. More...
virtual void	initialSetup () override
	Override to initialize batch backups. More...

Static Public Member Functions
static InputParameters	validParams ()

Protected Attributes
Sampler &	_sampler
	Sampler to utilize for creating MultiApps. More...
const StochasticTools::MultiAppMode	_mode
	The Sup-application solve mode. More...

Private Member Functions
bool	solveStepBatch (Real dt, Real target_time, bool auto_advance=true)
	Helper method for running in mode='batch'. More...
std::vector< std::shared_ptr< StochasticToolsTransfer > >	getActiveStochasticToolsTransfers (Transfer::DIRECTION direction)
	Helper for getting StochasticToolsTransfer objects. More...

Private Attributes
std::vector< std::vector< std::shared_ptr< Backup > > >	_batch_backup
	Storage for batch-restore mode; the outer vector if for the local stochastic data and the inner vector is for the number of sub-apps. More...

Detailed Description

Definition at line 25 of file SamplerTransientMultiApp.h.

Constructor & Destructor Documentation

SamplerTransientMultiApp()

SamplerTransientMultiApp::SamplerTransientMultiApp

(

const InputParameters &

parameters

)

Definition at line 47 of file SamplerTransientMultiApp.C.

  : TransientMultiApp(parameters),
    SamplerInterface(this),
    _sampler(SamplerInterface::getSampler("sampler")),
    _mode(getParam<MooseEnum>("mode").getEnum<StochasticTools::MultiAppMode>())
{
  if (_mode == StochasticTools::MultiAppMode::BATCH_RESTORE)
    init(n_processors());
  else if (_mode == StochasticTools::MultiAppMode::NORMAL)
    init(_sampler.getNumberOfRows());
  else
    paramError("mode",
               "The supplied mode, '",
               getParam<MooseEnum>("mode"),
               "', currently is not implemented for the SamplerTransientMultiApp, the available "
               "options are 'normal' or 'batch-restore'.");
}

Member Function Documentation

getActiveStochasticToolsTransfers()

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

private

Helper for getting StochasticToolsTransfer objects.

This is a copy from SamplerFullSolveMultiapp, but the alternative is to create an intermediate base. But, given the inheritance difference between these object that gets rather complex, so a few lines of copied code is better for now.

Definition at line 141 of file SamplerTransientMultiApp.C.

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

Referenced by solveStepBatch().

initialSetup()

void SamplerTransientMultiApp::initialSetup ( )

overridevirtual

Override to initialize batch backups.

Definition at line 66 of file SamplerTransientMultiApp.C.

{
  TransientMultiApp::initialSetup();
 
  // Perform initial backup for the batch sub-applications
  if (_mode == StochasticTools::MultiAppMode::BATCH_RESTORE)
  {
    dof_id_type n = _sampler.getNumberOfLocalRows();
    _batch_backup.resize(n);
    for (MooseIndex(n) i = 0; i < n; ++i)
      for (MooseIndex(_my_num_apps) j = 0; j < _my_num_apps; j++)
        _batch_backup[i].emplace_back(_apps[j]->backup());
  }
}

solveStep()

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

overridevirtual

Override solveStep to allow for batch execution.

Definition at line 82 of file SamplerTransientMultiApp.C.

{
  bool last_solve_converged = true;
  if (_mode == StochasticTools::MultiAppMode::BATCH_RESTORE)
    last_solve_converged = solveStepBatch(dt, target_time, auto_advance);
  else
    last_solve_converged = TransientMultiApp::solveStep(dt, target_time, auto_advance);
  return last_solve_converged;
}

solveStepBatch()

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

private

Helper method for running in mode='batch'.

Definition at line 93 of file SamplerTransientMultiApp.C.

{
  // 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->initializeToMultiapp();
  for (auto transfer : from_transfers)
    transfer->initializeFromMultiapp();
 
  // Perform batch MultiApp solves
  dof_id_type num_items = _sampler.getNumberOfLocalRows();
  for (MooseIndex(num_items) i = 0; i < num_items; ++i)
  {
    if (_mode == StochasticTools::MultiAppMode::BATCH_RESTORE)
      for (MooseIndex(_my_num_apps) j = 0; j < _my_num_apps; j++)
        _apps[j]->restore(_batch_backup[i][j]);
 
    for (auto transfer : to_transfers)
      transfer->executeToMultiapp();
 
    last_solve_converged = TransientMultiApp::solveStep(dt, target_time, auto_advance);
 
    for (auto transfer : from_transfers)
      transfer->executeFromMultiapp();
 
    if (_mode == StochasticTools::MultiAppMode::BATCH_RESTORE)
      for (MooseIndex(_my_num_apps) j = 0; j < _my_num_apps; j++)
        _batch_backup[i][j] = _apps[j]->backup();
  }
 
  // 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().

validParams()

InputParameters SamplerTransientMultiApp::validParams ( )

static

Definition at line 20 of file SamplerTransientMultiApp.C.

{
  InputParameters params = TransientMultiApp::validParams();
  params += SamplerInterface::validParams();
  params.addClassDescription("Creates a sub-application for each row of each Sampler matrix.");
  params.addParam<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;
 
  // use "batch-restore=2" to be consistent with SamplerFullSolveMultiApp and use the
  // allow_out_of_range flag to allow the StochasticToolsTransfer object to inspect the MultiApp
  // object parameters without triggering an assert.
  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' creates on sub-application for each processor and re-executes for each row.");
 
  return params;
}

Member Data Documentation

_batch_backup

std::vector<std::vector<std::shared_ptr<Backup> > > SamplerTransientMultiApp::_batch_backup

private

Storage for batch-restore mode; the outer vector if for the local stochastic data and the inner vector is for the number of sub-apps.

The later is 1 for this object, but it is included in case that changes in the future or in child classes

Definition at line 68 of file SamplerTransientMultiApp.h.

Referenced by initialSetup(), and solveStepBatch().

_mode

const StochasticTools::MultiAppMode SamplerTransientMultiApp::_mode

protected

The Sup-application solve mode.

Definition at line 47 of file SamplerTransientMultiApp.h.

Referenced by initialSetup(), SamplerTransientMultiApp(), solveStep(), and solveStepBatch().

_sampler

Sampler& SamplerTransientMultiApp::_sampler

protected

Sampler to utilize for creating MultiApps.

Definition at line 44 of file SamplerTransientMultiApp.h.

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

---

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

• stochastic_tools/include/multiapps/SamplerTransientMultiApp.h
• stochastic_tools/src/multiapps/SamplerTransientMultiApp.C