A Control object for receiving data from a master application Sampler object. More...

#include <MultiAppCommandLineControl.h>

Inheritance diagram for MultiAppCommandLineControl:

Public Member Functions
	MultiAppCommandLineControl (const InputParameters &parameters)

virtual void	initialSetup () override final
	Do not allow the use of initialSetup, because this class is designed to operate on PRE_MULTIAPP_SETUP, which occurs before this callback. More...

virtual void	execute () override

Static Public Member Functions
static InputParameters	validParams ()

Protected Attributes
std::shared_ptr< MultiApp >	_multi_app
	The MultiApp this Transfer is transferring data to or from. More...

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

const std::vector< std::string > &	_param_names
	Storage for the parameter names to be applied. More...

Detailed Description

A Control object for receiving data from a master application Sampler object.

Definition at line 29 of file MultiAppCommandLineControl.h.

Constructor & Destructor Documentation

◆ MultiAppCommandLineControl()

MultiAppCommandLineControl::MultiAppCommandLineControl ( const InputParameters & parameters )

Definition at line 42 of file MultiAppCommandLineControl.C.

   : Control(parameters),
     SamplerInterface(this),
     _multi_app(_fe_problem.getMultiApp(getParam<MultiAppName>("multi_app"))),
     _sampler(SamplerInterface::getSampler("sampler")),
     _param_names(getParam<std::vector<std::string>>("param_names"))
 {
   if (!_sampler.getParamTempl<ExecFlagEnum>("execute_on").contains(EXEC_PRE_MULTIAPP_SETUP))
     _sampler.paramError(
         "execute_on",
         "The sampler object, '",
         _sampler.name(),
         "', is being used by the '",
         name(),
         "' object, thus the 'execute_on' of the sampler must include 'PRE_MULTIAPP_SETUP'.");
  
   bool batch_reset = _multi_app->isParamValid("mode") &&
                      (_multi_app->getParamTempl<MooseEnum>("mode") == "batch-reset");
   bool batch_restore = _multi_app->isParamValid("mode") &&
                        (_multi_app->getParamTempl<MooseEnum>("mode") == "batch-restore");
   if (batch_reset)
     ; // Do not perform the App count test, because in batch mode there is only one
  
   else if (batch_restore)
     _multi_app->paramError(
         "mode",
         "The MultiApp object, '",
         _multi_app->name(),
         "', supplied to the '",
         name(),
         "' object is setup to run in 'batch-restore' mode, when using this mode command line "
         "arguments cannot be modified; batch-reset mode should be used instead.");
  
   else if (_multi_app->numGlobalApps() != _sampler.getNumberOfRows())
     mooseError("The number of sub apps (",
                _multi_app->numGlobalApps(),
                ") created by MultiApp object '",
                _multi_app->name(),
                "' must be equal to the number for rows (",
                _sampler.getNumberOfRows(),
                ") for the '",
                _sampler.name(),
                "' Sampler object.");
 }

Member Function Documentation

◆ execute()

void MultiAppCommandLineControl::execute ( )

overridevirtual

Definition at line 95 of file MultiAppCommandLineControl.C.

 {
   std::vector<std::string> cli_args;
  
   if (_sampler.getNumberOfCols() != _param_names.size())
     paramError("param_names",
                "The number of columns (",
                _sampler.getNumberOfCols(),
                ") must match the number of parameters (",
                _param_names.size(),
                ").");
  
   // For SamplerFullSolveMultiApp, to avoid storing duplicated param_names for each sampler, we
   // store only param_names once in "cli_args". For other MultApp, we store the full information
   // of params_names and values for each sampler.
  
   if (std::dynamic_pointer_cast<SamplerFullSolveMultiApp>(_multi_app) == nullptr)
   {
     for (dof_id_type row = _sampler.getLocalRowBegin(); row < _sampler.getLocalRowEnd(); ++row)
     {
       std::vector<Real> data = _sampler.getNextLocalRow();
       std::ostringstream oss;
       for (std::size_t col = 0; col < data.size(); ++col)
       {
         if (col > 0)
           oss << ";";
         oss << _param_names[col] << "=" << Moose::stringify(data[col]);
       }
  
       cli_args.push_back(oss.str());
     }
   }
   else
   {
     std::ostringstream oss;
     for (dof_id_type col = 0; col < _sampler.getNumberOfCols(); ++col)
     {
       if (col > 0)
         oss << ";";
       oss << _param_names[col];
     }
  
     cli_args.push_back(oss.str());
   }
  
   setControllableValueByName<std::vector<std::string>>(
       "MultiApp", _multi_app->name(), "cli_args", cli_args);
 }

◆ initialSetup()

void MultiAppCommandLineControl::initialSetup ( )

finaloverridevirtual

Do not allow the use of initialSetup, because this class is designed to operate on PRE_MULTIAPP_SETUP, which occurs before this callback.

This will prevent a child class adding something to this function without it doing anything.

Definition at line 88 of file MultiAppCommandLineControl.C.

 {
   // Do not put anything here, this method is being called after execute because the execute_on
   // is set to PRE_MULTIAPP_SETUP for this class. It won't work any other way.
 }

◆ validParams()

InputParameters MultiAppCommandLineControl::validParams ( )

static

Definition at line 22 of file MultiAppCommandLineControl.C.

 {
   InputParameters params = Control::validParams();
   params += SamplerInterface::validParams();
   params.addClassDescription("Control for modifying the command line arguments of MultiApps.");
  
   // Set and suppress the 'execute_on' flag, it doesn't work with any other flag
   params.set<ExecFlagEnum>("execute_on") = {EXEC_PRE_MULTIAPP_SETUP};
   params.suppressParameter<ExecFlagEnum>("execute_on");
  
   params.addRequiredParam<MultiAppName>("multi_app", "The name of the MultiApp to control.");
   params.addParam<SamplerName>(
       "sampler",
       "The Sampler object to utilize for altering the command line options of the MultiApp.");
   params.addParam<std::vector<std::string>>(
       "param_names", "The names of the command line parameters to set via the sampled data.");
  
   return params;
 }