#include <ParameterStudyAction.h>

Inheritance diagram for ParameterStudyAction:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	ParameterStudyAction (const InputParameters &params)

virtual void	act () override

void	timedAct ()

virtual void	addRelationshipManagers (Moose::RelationshipManagerType when_type)

MooseObjectName	uniqueActionName () const

const std::string &	specificTaskName () const

const std::set< std::string > &	getAllTasks () const

void	appendTask (const std::string &task)

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

PerfGraph &	perfGraph ()

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

static MooseEnum	samplingTypes ()
	Return an enum of available sampling types for the study.

static MultiMooseEnum	distributionTypes ()
	Return an enum of available distributions for the study.

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)

Public Attributes
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

Static Public Attributes
static const std::string	unique_action_name_param

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

static constexpr auto	SYSTEM

static constexpr auto	NAME

Protected Member Functions
DistributionName	distributionName (unsigned int count) const
	The perscribed name of the distribution.

std::vector< DistributionName >	distributionNames (unsigned int full_count) const

SamplerName	samplerName () const
	The perscribed name of the sampler created in this action.

MultiAppName	multiappName () const
	The perscribed name of the multiapp created in this action.

std::string	samplerReceiverName () const
	The perscribed name of the control given to the sub-app for parameter transfer.

std::string	multiappControlName () const
	The perscribed name of the command-line control created in this action.

std::string	parameterTransferName () const
	The perscribed name of the parameter transfer created in this action.

std::string	reporterTransferName () const
	The perscribed name of the reporter transfer created in this action.

std::string	stochasticReporterName () const
	The perscribed name of the QoI storage object created in this action.

OutputName	outputName (std::string type) const
	The perscribed name of the output objects created in this action.

ReporterName	quantityOfInterestName (const ReporterName &qoi) const
	The name of the reporter values in the StochasticReporter representing the QoIs.

std::string	statisticsName () const
	The perscribed name of the statistics object created in this action.

template<typename T >
T	getDistributionParam (std::string param, unsigned int count) const
	Helper function for getting the param value for the distribution index.

void	showObject (std::string type, std::string name, const InputParameters &params) const
	Helper function to show the object being built.

bool	addRelationshipManagers (Moose::RelationshipManagerType when_type, const InputParameters &moose_object_pars)

void	associateWithParameter (const std::string &param_name, InputParameters &params) const

void	associateWithParameter (const InputParameters &from_params, const std::string &param_name, InputParameters &params) const

const T &	getMeshProperty (const std::string &data_name, const std::string &prefix)

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

bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const

bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const

bool	hasMeshProperty (const std::string &data_name) const

bool	hasMeshProperty (const std::string &data_name) const

std::string	meshPropertyName (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

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

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

Static Protected Member Functions
static std::string	meshPropertyName (const std::string &data_name, const std::string &prefix)

Protected Attributes
std::string	_registered_identifier

std::string	_specific_task_name

std::set< std::string >	_all_tasks

ActionWarehouse &	_awh

const std::string &	_current_task

std::shared_ptr< MooseMesh > &	_mesh

std::shared_ptr< MooseMesh > &	_displaced_mesh

std::shared_ptr< FEProblemBase > &	_problem

PerfID	_act_timer

MooseApp &	_app

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

MooseApp &	_pg_moose_app

const std::string	_prefix

const Parallel::Communicator &	_communicator

Private Member Functions
unsigned int	inferMultiAppMode ()
	This function will infer the best way to run the multiapps.

bool	addRelationshipManager (Moose::RelationshipManagerType input_rm_type, const InputParameters &moose_object_pars, std::string rm_name, Moose::RelationshipManagerType rm_type, Moose::RelationshipManagerInputParameterCallback rm_input_parameter_func, Moose::RMSystemType sys_type=Moose::RMSystemType::NONE)

virtual std::string	meshPropertyPrefix (const std::string &data_name) const

const RestartableDataValue &	getMeshPropertyInternal (const std::string &data_name, const std::string &prefix) const

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

Static Private Member Functions
static std::vector< std::map< std::string, bool > >	samplerParameters ()
	This is a vector associating the sampling type with a list of associated parameters The list includes the parameter name and whether or not it is required.

static std::vector< std::vector< std::string > >	distributionParameters ()
	This is a vector associating the distribution type and a list of parameters that are needed.

static std::set< std::string >	statisticsParameters ()
	List of parameters that are only associated with computing statistics.

static const hit::Node *	getHitNode (const InputParameters &params)

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

Private Attributes
const std::vector< std::string > &	_parameters
	The inputted parameter vector.

const unsigned int	_sampling_type
	The sampling type.

const MultiMooseEnum	_distributions
	The distributions.

const unsigned int	_multiapp_mode
	The multiapp mode.

const bool	_compute_stats
	Whether or not we are computing statistics.

const bool	_show_objects
	Switch to show the objects being built on console.

const ParallelParamObject &	_parent

MooseApp &	_meta_data_app

const MooseObject *const	_meta_data_object

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

Detailed Description

Definition at line 18 of file ParameterStudyAction.h.

Constructor & Destructor Documentation

◆ ParameterStudyAction()

ParameterStudyAction::ParameterStudyAction ( const InputParameters & params )

Definition at line 170 of file ParameterStudyAction.C.

  : Action(parameters),
    _parameters(getParam<std::vector<std::string>>("parameters")),
    _sampling_type(getParam<MooseEnum>("sampling_type")),
    _distributions(isParamValid("distributions") ? getParam<MultiMooseEnum>("distributions")
                                                 : MultiMooseEnum("")),
    _multiapp_mode(inferMultiAppMode()),
    _compute_stats(isParamValid("quantities_of_interest") && getParam<bool>("compute_statistics")),
    _show_objects(getParam<bool>("show_study_objects"))
{
  // Check sampler parameters
  const auto sampler_params = samplerParameters();
  const auto this_sampler_params = sampler_params[_sampling_type];
  // Check required sampler parameters
  for (const auto & param : this_sampler_params)
    if (param.second && !isParamValid(param.first))
      paramError("sampling_type",
                 "The ",
                 param.first,
                 " parameter is required to build the requested sampling type.");
  // Check unused parameters
  std::string msg = "";
  for (unsigned int i = 0; i < sampler_params.size(); ++i)
    for (const auto & param : sampler_params[i])
      if (this_sampler_params.find(param.first) == this_sampler_params.end() &&
          parameters.isParamSetByUser(param.first))
        msg += (msg.empty() ? "" : ", ") + param.first;
  if (!msg.empty())
    paramError("sampling_type",
               "The following parameters are unused for the selected sampling type: ",
               msg);
 
  // Check distribution parameters
  const auto distribution_params = distributionParameters();
  std::vector<unsigned int> dist_count(distribution_params.size(), 0);
  for (const auto & dist : _distributions)
    dist_count[(unsigned int)dist]++;
  msg = "";
  for (unsigned int i = 0; i < distribution_params.size(); ++i)
    for (const auto & param : distribution_params[i])
    {
      // Check if parameter was set
      if (dist_count[i] > 0 && !isParamValid(param))
        paramError("distributions",
                   "The ",
                   param,
                   " parameter is required to build the listed distributions.");
      // Check if parameter has correct size
      else if (dist_count[i] > 0 && getParam<std::vector<Real>>(param).size() != dist_count[i])
        paramError("distributions",
                   "The number of entries in ",
                   param,
                   " does not match the number of required entries (",
                   dist_count[i],
                   ") to build the listed distributions.");
      // Check if parameter was set and unused
      else if (dist_count[i] == 0 && parameters.isParamSetByUser(param))
        msg += (msg.empty() ? "" : ", ") + param;
    }
  if (!msg.empty())
    paramError(
        "distributions", "The following parameters are unused for the listed distributions: ", msg);
 
  // Check statistics parameters
  if (!_compute_stats)
  {
    msg = "";
    for (const auto & param : statisticsParameters())
      if (parameters.isParamSetByUser(param))
        msg += (msg.empty() ? "" : ", ") + param;
    if (!msg.empty())
      paramError("compute_statistics",
                 "The following parameters are unused since statistics are not being computed: ",
                 msg);
  }
}

Member Function Documentation

◆ act()

void ParameterStudyAction::act ( )

overridevirtual

Implements Action.

Definition at line 260 of file ParameterStudyAction.C.

{
  if (_current_task == "meta_action")
  {
    const auto stm_actions = _awh.getActions<StochasticToolsAction>();
    if (stm_actions.empty())
    {
      auto params = _action_factory.getValidParams("StochasticToolsAction");
      params.set<bool>("_built_by_moose") = true;
      params.set<std::string>("registered_identifier") = "(AutoBuilt)";
 
      std::shared_ptr<Action> action = _action_factory.create(
          "StochasticToolsAction", _name + "_stochastic_tools_action", params);
      _awh.addActionBlock(action);
 
      if (_show_objects)
        showObject("StochasticToolsAction", _name + "_stochastic_tools_action", params);
    }
  }
  else if (_current_task == "add_distribution")
  {
    // This map is used to keep track of how many of a certain
    // distribution is being created.
    std::unordered_map<std::string, unsigned int> dist_count;
    for (const auto & dt : distributionTypes().getNames())
      dist_count[dt] = 0;
 
    // We will have a single call to addDistribution for each entry
    // So declare these quantities and set in the if statements
    std::string distribution_type;
    InputParameters params = emptyInputParameters();
 
    // Loop through the inputted distributions
    unsigned int full_count = 0;
    for (const auto & dist : _distributions)
    {
      // Convenient reference to the current count
      unsigned int & count = dist_count[dist.name()];
 
      // Set the distribution type and parameters
      if (dist == "normal")
      {
        distribution_type = "Normal";
        params = _factory.getValidParams(distribution_type);
        params.set<Real>("mean") = getDistributionParam<Real>("normal_mean", count);
        params.set<Real>("standard_deviation") =
            getDistributionParam<Real>("normal_standard_deviation", count);
      }
      else if (dist == "uniform")
      {
        distribution_type = "Uniform";
        params = _factory.getValidParams(distribution_type);
        params.set<Real>("lower_bound") = getDistributionParam<Real>("uniform_lower_bound", count);
        params.set<Real>("upper_bound") = getDistributionParam<Real>("uniform_upper_bound", count);
      }
      else if (dist == "weibull")
      {
        distribution_type = "Weibull";
        params = _factory.getValidParams(distribution_type);
        params.set<Real>("location") = getDistributionParam<Real>("weibull_location", count);
        params.set<Real>("scale") = getDistributionParam<Real>("weibull_scale", count);
        params.set<Real>("shape") = getDistributionParam<Real>("weibull_shape", count);
      }
      else if (dist == "lognormal")
      {
        distribution_type = "Lognormal";
        params = _factory.getValidParams(distribution_type);
        params.set<Real>("location") = getDistributionParam<Real>("lognormal_location", count);
        params.set<Real>("scale") = getDistributionParam<Real>("lognormal_scale", count);
      }
      else if (dist == "tnormal")
      {
        distribution_type = "TruncatedNormal";
        params = _factory.getValidParams(distribution_type);
        params.set<Real>("mean") = getDistributionParam<Real>("tnormal_mean", count);
        params.set<Real>("standard_deviation") =
            getDistributionParam<Real>("tnormal_standard_deviation", count);
        params.set<Real>("lower_bound") = getDistributionParam<Real>("tnormal_lower_bound", count);
        params.set<Real>("upper_bound") = getDistributionParam<Real>("tnormal_upper_bound", count);
      }
      else
        paramError("distributions", "Unknown distribution type.");
 
      // Add the distribution
      _problem->addDistribution(distribution_type, distributionName(full_count), params);
      if (_show_objects)
        showObject(distribution_type, distributionName(full_count), params);
 
      // Increment the counts
      count++;
      full_count++;
    }
  }
  else if (_current_task == "add_sampler")
  {
    // We will have a single call to addSampler
    // So declare these quantities and set in the if statements
    std::string sampler_type;
    InputParameters params = emptyInputParameters();
 
    // Set the distribution type and parameters
    // monte-carlo or lhs
    if (_sampling_type == 0 || _sampling_type == 1)
    {
      sampler_type = _sampling_type == 0 ? "MonteCarlo" : "LatinHypercube";
      params = _factory.getValidParams(sampler_type);
      params.set<dof_id_type>("num_rows") = getParam<dof_id_type>("num_samples");
      params.set<std::vector<DistributionName>>("distributions") =
          distributionNames(_distributions.size());
    }
    // cartesian-product
    else if (_sampling_type == 2)
    {
      sampler_type = "CartesianProduct";
      params = _factory.getValidParams(sampler_type);
      params.set<std::vector<Real>>("linear_space_items") =
          getParam<std::vector<Real>>("linear_space_items");
    }
    // csv
    else if (_sampling_type == 3)
    {
      sampler_type = "CSVSampler";
      params = _factory.getValidParams(sampler_type);
      params.set<FileName>("samples_file") = getParam<FileName>("csv_samples_file");
      if (isParamValid("csv_column_indices") && isParamValid("csv_column_names"))
        paramError("csv_column_indices",
                   "'csv_column_indices' and 'csv_column_names' cannot both be set.");
      else if (isParamValid("csv_column_indices"))
        params.set<std::vector<dof_id_type>>("column_indices") =
            getParam<std::vector<dof_id_type>>("csv_column_indices");
      else if (isParamValid("csv_column_names"))
        params.set<std::vector<std::string>>("column_names") =
            getParam<std::vector<std::string>>("csv_column_names");
    }
    // input-matrix
    else if (_sampling_type == 4)
    {
      sampler_type = "InputMatrix";
      params = _factory.getValidParams(sampler_type);
      params.set<RealEigenMatrix>("matrix") = getParam<RealEigenMatrix>("input_matrix");
    }
    else
      paramError("sampling_type", "Unknown sampling type.");
 
    // Need to set the right execute_on for command-line control
    if (_multiapp_mode <= 1)
      params.set<ExecFlagEnum>("execute_on") = {EXEC_PRE_MULTIAPP_SETUP};
    else
      params.set<ExecFlagEnum>("execute_on") = {EXEC_INITIAL};
 
    // Set the minimum number of procs
    params.set<unsigned int>("min_procs_per_row") = getParam<unsigned int>("min_procs_per_sample");
 
    // Add the sampler
    _problem->addSampler(sampler_type, samplerName(), params);
    if (_show_objects)
      showObject(sampler_type, samplerName(), params);
  }
  else if (_current_task == "add_multi_app")
  {
    auto params = _factory.getValidParams("SamplerFullSolveMultiApp");
 
    // Dealing with failed solves
    params.set<bool>("ignore_solve_not_converge") = getParam<bool>("ignore_solve_not_converge");
 
    // Set input file
    params.set<std::vector<FileName>>("input_files") = {getParam<FileName>("input")};
 
    // Set the Sampler
    params.set<SamplerName>("sampler") = samplerName();
 
    // Set parameters based on the sampling mode
    // normal
    if (_multiapp_mode == 0)
      params.set<MooseEnum>("mode") = "normal";
    // batch-reset
    else if (_multiapp_mode == 1)
      params.set<MooseEnum>("mode") = "batch-reset";
    // batch-restore variants
    else
    {
      // Set the mode to 'batch-restore'
      params.set<MooseEnum>("mode") = "batch-restore";
 
      // If we are doing batch-restore, the parameters must be controllable.
      // So we will add the necessary control to the sub-app using command-line
      std::string clia = "Controls/" + samplerReceiverName() + "/type=SamplerReceiver";
      params.set<std::vector<CLIArgString>>("cli_args").push_back(clia);
 
      // batch-keep-solution
      if (_multiapp_mode == 3)
      {
        params.set<bool>("keep_solution_during_restore") = true;
        // Conceptually all these runs are not 'sequential in time' (moving along a transient)
        // but rather simply restarted from the same solution
        params.set<bool>("update_old_solution_when_keeping_solution_during_restore") = false;
      }
      // batch-no-restore
      else if (_multiapp_mode == 4)
        params.set<bool>("no_restore") = true;
    }
 
    // Set the minimum number of procs
    params.set<unsigned int>("min_procs_per_app") = getParam<unsigned int>("min_procs_per_sample");
 
    // Setting execute_on to make sure things happen in the correct order
    params.set<ExecFlagEnum>("execute_on") = {EXEC_TIMESTEP_BEGIN};
 
    // Add the multiapp
    _problem->addMultiApp("SamplerFullSolveMultiApp", multiappName(), params);
    if (_show_objects)
      showObject("SamplerFullSolveMultiApp", multiappName(), params);
  }
  else if (_current_task == "add_transfer")
  {
    // Add the parameter transfer if we are doing 'batch-restore'
    if (_multiapp_mode >= 2)
    {
      auto params = _factory.getValidParams("SamplerParameterTransfer");
      params.set<MultiAppName>("to_multi_app") = multiappName();
      params.set<SamplerName>("sampler") = samplerName();
      params.set<std::vector<std::string>>("parameters") = _parameters;
      _problem->addTransfer("SamplerParameterTransfer", parameterTransferName(), params);
      if (_show_objects)
        showObject("SamplerParameterTransfer", parameterTransferName(), params);
    }
 
    // Add reporter transfer if QoIs have been specified
    if (isParamValid("quantities_of_interest"))
    {
      auto params = _factory.getValidParams("SamplerReporterTransfer");
      params.set<MultiAppName>("from_multi_app") = multiappName();
      params.set<SamplerName>("sampler") = samplerName();
      params.set<std::string>("stochastic_reporter") = stochasticReporterName();
      params.set<std::vector<ReporterName>>("from_reporter") =
          getParam<std::vector<ReporterName>>("quantities_of_interest");
      params.set<std::string>("prefix") = "";
      _problem->addTransfer("SamplerReporterTransfer", reporterTransferName(), params);
      if (_show_objects)
        showObject("SamplerReporterTransfer", reporterTransferName(), params);
    }
  }
  else if (_current_task == "add_output")
  {
    const auto & output = getParam<MultiMooseEnum>("output_type");
 
    // Add csv output
    if (output.isValueSet("csv"))
    {
      auto params = _factory.getValidParams("CSV");
      params.set<ExecFlagEnum>("execute_on") = {EXEC_TIMESTEP_END};
      _problem->addOutput("CSV", outputName("csv"), params);
      if (_show_objects)
        showObject("CSV", outputName("csv"), params);
    }
 
    // Add json output
    if (output.isValueSet("json") || _compute_stats)
    {
      auto params = _factory.getValidParams("JSON");
      params.set<ExecFlagEnum>("execute_on") = {EXEC_TIMESTEP_END};
      _problem->addOutput("JSON", outputName("json"), params);
      if (_show_objects)
        showObject("JSON", outputName("json"), params);
    }
  }
  else if (_current_task == "add_reporter")
  {
    // Add stochastic reporter object
    auto params = _factory.getValidParams("StochasticMatrix");
 
    // Ideally this would be based on the number of samples since gathering
    // data onto a single processor can be memory and run-time expensive,
    // but most people want everything in one output file
    params.set<MooseEnum>("parallel_type") = "ROOT";
 
    // Supply the sampler for output
    params.set<SamplerName>("sampler") = samplerName();
 
    // Set the column names if supplied or identifiable with "parameters"
    auto & names = params.set<std::vector<ReporterValueName>>("sampler_column_names");
    if (isParamValid("sampler_column_names"))
      names = getParam<std::vector<ReporterValueName>>("sampler_column_names");
    else
    {
      // There isn't a guaranteed mapping if using brackets
      bool has_bracket = false;
      for (const auto & param : _parameters)
        if (param.find("[") != std::string::npos)
          has_bracket = true;
 
      // If no brackets, then there is mapping, so use parameter names
      if (!has_bracket)
        for (auto param : _parameters)
        {
          // Reporters don't like '/' in the name, so replace those with '_'
          std::replace(param.begin(), param.end(), '/', '_');
          names.push_back(param);
        }
    }
 
    // Specify output objects
    const auto & output_type = getParam<MultiMooseEnum>("output_type");
    auto & outputs = params.set<std::vector<OutputName>>("outputs");
    if (output_type.isValueSet("csv"))
      outputs.push_back(outputName("csv"));
    if (output_type.isValueSet("json"))
      outputs.push_back(outputName("json"));
    if (output_type.isValueSet("none"))
      outputs = {"none"};
 
    params.set<ExecFlagEnum>("execute_on") = {EXEC_TIMESTEP_END};
    _problem->addReporter("StochasticMatrix", stochasticReporterName(), params);
    if (_show_objects)
      showObject("StochasticReporter", stochasticReporterName(), params);
 
    // Add statistics object
    if (_compute_stats)
    {
      auto params = _factory.getValidParams("StatisticsReporter");
      auto & reps = params.set<std::vector<ReporterName>>("reporters");
      for (const auto & qoi : getParam<std::vector<ReporterName>>("quantities_of_interest"))
        reps.push_back(quantityOfInterestName(qoi));
      params.set<MultiMooseEnum>("compute") = getParam<MultiMooseEnum>("statistics");
      params.set<MooseEnum>("ci_method") = "percentile";
      params.set<std::vector<Real>>("ci_levels") = getParam<std::vector<Real>>("ci_levels");
      params.set<unsigned int>("ci_replicates") = getParam<unsigned int>("ci_replicates");
      params.set<ExecFlagEnum>("execute_on") = {EXEC_TIMESTEP_END};
      params.set<std::vector<OutputName>>("outputs") = {outputName("json")};
      _problem->addReporter("StatisticsReporter", statisticsName(), params);
      if (_show_objects)
        showObject("StatisticsReporter", statisticsName(), params);
    }
  }
  else if (_current_task == "add_control")
  {
    // Add command-line control if the multiapp mode warrants it
    if (_multiapp_mode <= 1)
    {
      auto params = _factory.getValidParams("MultiAppSamplerControl");
      params.set<MultiAppName>("multi_app") = multiappName();
      params.set<SamplerName>("sampler") = samplerName();
      params.set<std::vector<std::string>>("param_names") = _parameters;
      auto control =
          _factory.create<Control>("MultiAppSamplerControl", multiappControlName(), params);
      _problem->getControlWarehouse().addObject(control);
      if (_show_objects)
        showObject("MultiAppSamplerControl", multiappControlName(), params);
    }
  }
}

◆ distributionName()

DistributionName ParameterStudyAction::distributionName ( unsigned int count ) const

protected

The perscribed name of the distribution.

Need this to give the right name to the sampler

Parameters

count The index of the distribution

Returns: Name of the distribution

Definition at line 613 of file ParameterStudyAction.C.

{
  return "study_distribution_" + std::to_string(count);
}

Referenced by act(), and distributionNames().

◆ distributionNames()

std::vector< DistributionName > ParameterStudyAction::distributionNames ( unsigned int full_count ) const

protected

Definition at line 619 of file ParameterStudyAction.C.

{
  std::vector<DistributionName> dist_names;
  for (const auto & i : make_range(full_count))
    dist_names.push_back(distributionName(i));
  return dist_names;
}

Referenced by act().

◆ distributionParameters()

std::vector< std::vector< std::string > > ParameterStudyAction::distributionParameters ( )

staticprivate

This is a vector associating the distribution type and a list of parameters that are needed.

Definition at line 688 of file ParameterStudyAction.C.

{
  // normal, uniform, weibull, lognormal, tnormal
  return {
      {"normal_mean", "normal_standard_deviation"},
      {"uniform_lower_bound", "uniform_upper_bound"},
      {"weibull_location", "weibull_scale", "weibull_shape"},
      {"lognormal_location", "lognormal_scale"},
      {"tnormal_mean", "tnormal_standard_deviation", "tnormal_lower_bound", "tnormal_upper_bound"}};
}

Referenced by ParameterStudyAction().

◆ distributionTypes()

MultiMooseEnum ParameterStudyAction::distributionTypes ( )

static

Return an enum of available distributions for the study.

Definition at line 254 of file ParameterStudyAction.C.

{
  return MultiMooseEnum("normal=0 uniform=1 weibull=2 lognormal=3 tnormal=4");
}

Referenced by act(), and validParams().

◆ getDistributionParam()

template<typename T >

T ParameterStudyAction::getDistributionParam	(	std::string	param,
		unsigned int	count
	)		const

protected

Helper function for getting the param value for the distribution index.

Template Parameters

T	The type of parameter, it will be trying to get std::vector<T>

Parameters

param	The name of the parameter
count	The index of the specific distribution

Returns: T The inputted value of the parameter at the given index

Definition at line 180 of file ParameterStudyAction.h.

{
  const auto & val = getParam<std::vector<T>>(param);
  return val[count];
}

◆ inferMultiAppMode()

unsigned int ParameterStudyAction::inferMultiAppMode ( )

private

This function will infer the best way to run the multiapps.

Returns: unsigned int The multiapp execution mode, see the 'multiapp_mode' input param for details

Definition at line 706 of file ParameterStudyAction.C.

{
  if (isParamValid("multiapp_mode"))
    return getParam<MooseEnum>("multiapp_mode");
 
  const unsigned int default_mode = 1;
 
  // First obvious thing is if it is a parsed parameter, indicated by the lack of '/'
  for (const auto & param : _parameters)
    if (param.find("/") == std::string::npos)
      return default_mode;
  // Next we'll see if there is a GlobalParam
  for (const auto & param : _parameters)
    if (param.find("GlobalParams") != std::string::npos)
      return default_mode;
 
  // Now for the difficult check
  // Parse input file and create root hit node
  const auto input_filename = MooseUtils::realpath(getParam<FileName>("input"));
  std::ifstream f(input_filename);
  std::string input((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
  std::unique_ptr<hit::Node> root(hit::parse(input_filename, input));
 
  // Walk through the input and see if every param is controllable
  AreParametersControllableWalker control_walker(_parameters, _app);
  root->walk(&control_walker, hit::NodeType::Section);
  if (!control_walker.areControllable())
    return default_mode;
 
  // Walk through the input and determine how the problem is being executed
  ExecutionTypeWalker exec_walker;
  root->walk(&exec_walker, hit::NodeType::Section);
  // If it is steady-state, then we don't need to restore
  if (exec_walker.getExecutionType() == 1)
    return 4;
  // If it is pseudo-transeint, then we can keep the solution
  else if (exec_walker.getExecutionType() == 2)
    return 3;
  // If it's transient or unknown, don't keep the solution and restore
  else
    return 2;
}

◆ multiappControlName()

std::string ParameterStudyAction::multiappControlName ( ) const

inlineprotected

The perscribed name of the command-line control created in this action.

Returns: std::string The name of the SamplerReceiver control.

Definition at line 68 of file ParameterStudyAction.h.

68{ return "study_multiapp_control"; }

Referenced by act().

◆ multiappName()

MultiAppName ParameterStudyAction::multiappName ( ) const

inlineprotected

The perscribed name of the multiapp created in this action.

Returns: MultiAppName The name of multiapp.

Definition at line 54 of file ParameterStudyAction.h.

54{ return "study_app"; }

Referenced by act().

◆ outputName()

OutputName ParameterStudyAction::outputName ( std::string type ) const

inlineprotected

The perscribed name of the output objects created in this action.

Parameters

type	The type of output object created

Returns: std::string The name of the StochasticReporter.

Definition at line 97 of file ParameterStudyAction.h.

97{ return type; }

Action::type

const std::string & type() const

Referenced by act().

◆ parameterTransferName()

std::string ParameterStudyAction::parameterTransferName ( ) const

inlineprotected

The perscribed name of the parameter transfer created in this action.

Returns: std::string The name of the SamplerParameterTransfer transfer.

Definition at line 75 of file ParameterStudyAction.h.

75{ return "study_parameter_transfer"; }

Referenced by act().

◆ quantityOfInterestName()

ReporterName ParameterStudyAction::quantityOfInterestName ( const ReporterName & qoi ) const

protected

The name of the reporter values in the StochasticReporter representing the QoIs.

Parameters

qoi	The name of the reporter on the sub-app

Returns: ReporterName The name of the QoI in StochasticReporter.

Definition at line 628 of file ParameterStudyAction.C.

{
  return ReporterName(stochasticReporterName(), qoi.getObjectName() + ":" + qoi.getValueName());
}

Referenced by act().

◆ reporterTransferName()

std::string ParameterStudyAction::reporterTransferName ( ) const

inlineprotected

The perscribed name of the reporter transfer created in this action.

Returns: std::string The name of the SamplerReporterTransfer transfer.

Definition at line 82 of file ParameterStudyAction.h.

82{ return "study_qoi_transfer"; }

Referenced by act().

◆ samplerName()

SamplerName ParameterStudyAction::samplerName ( ) const

inlineprotected

The perscribed name of the sampler created in this action.

Returns: SamplerName The name of sampler.

Definition at line 47 of file ParameterStudyAction.h.

47{ return "study_sampler"; }

Referenced by act().

◆ samplerParameters()

std::vector< std::map< std::string, bool > > ParameterStudyAction::samplerParameters ( )

staticprivate

This is a vector associating the sampling type with a list of associated parameters The list includes the parameter name and whether or not it is required.

Definition at line 677 of file ParameterStudyAction.C.

{
  // monte-carlo, lhs, cartesian-product, csv, input-matrix
  return {{{"num_samples", true}, {"distributions", true}},
          {{"num_samples", true}, {"distributions", true}},
          {{"linear_space_items", true}},
          {{"csv_samples_file", true}, {"csv_column_indices", false}, {"csv_column_names", false}},
          {{"input_matrix", true}}};
}

Referenced by ParameterStudyAction().

◆ samplerReceiverName()

std::string ParameterStudyAction::samplerReceiverName ( ) const

inlineprotected

The perscribed name of the control given to the sub-app for parameter transfer.

Returns: std::string The name of the SamplerReceiver control.

Definition at line 61 of file ParameterStudyAction.h.

61{ return "study_receiver"; }

Referenced by act().

◆ samplingTypes()

MooseEnum ParameterStudyAction::samplingTypes ( )

static

Return an enum of available sampling types for the study.

Definition at line 248 of file ParameterStudyAction.C.

{
  return MooseEnum("monte-carlo=0 lhs=1 cartesian-product=2 csv=3 input-matrix=4");
}

Referenced by validParams().

◆ showObject()

void ParameterStudyAction::showObject	(	std::string	type,
		std::string	name,
		const InputParameters &	params
	)		const

protected

Helper function to show the object being built.

Will display:

Object base type
Object type
Object name
Parameters set by the action

Parameters

type	The type of objecte, i.e. "SamplerFullSolveMultiApp"
name	The name of the object
params	The parameters used to create the object

Definition at line 634 of file ParameterStudyAction.C.

{
  // Output basic information
  std::string base_type = params.hasBase() ? params.getBase() : "Unknown";
  _console << "[ParameterStudy] "
           << "Base Type:  " << COLOR_YELLOW << base_type << COLOR_DEFAULT << "\n"
           << "                 Type:       " << COLOR_YELLOW << type << COLOR_DEFAULT << "\n"
           << "                 Name:       " << COLOR_YELLOW << name << COLOR_DEFAULT;
 
  // Gather parameters and their values if:
  // - It is not a private parameter
  // - Doesn't start with '_' (which usually indicates private)
  // - Parameter is set by this action
  // - Is not the "type" parameter
  std::map<std::string, std::string> param_map;
  for (const auto & it : params)
    if (!params.isPrivate(it.first) && it.first[0] != '_' && params.isParamSetByUser(it.first) &&
        it.first != "type")
    {
      std::stringstream ss;
      it.second->print(ss);
      param_map[it.first] = ss.str();
    }
 
  // Print the gathered parameters
  if (!param_map.empty())
    _console << "\n                 Parameters: ";
  bool first = true;
  for (const auto & it : param_map)
  {
    if (!first)
      _console << "\n" << std::string(29, ' ');
    _console << COLOR_YELLOW << std::setw(24) << it.first << COLOR_DEFAULT << " : " << COLOR_MAGENTA
             << it.second << COLOR_DEFAULT;
    first = false;
  }
 
  _console << std::endl;
}

Referenced by act().

◆ statisticsName()

std::string ParameterStudyAction::statisticsName ( ) const

inlineprotected

The perscribed name of the statistics object created in this action.

Returns: std::string The name of the StatisticsReporter.

Definition at line 112 of file ParameterStudyAction.h.

112{ return "study_statistics"; }

Referenced by act().

◆ statisticsParameters()

std::set< std::string > ParameterStudyAction::statisticsParameters ( )

staticprivate

List of parameters that are only associated with computing statistics.

Definition at line 700 of file ParameterStudyAction.C.

{
  return {"statistics", "ci_levels", "ci_replicates"};
}

Referenced by ParameterStudyAction().

◆ stochasticReporterName()

std::string ParameterStudyAction::stochasticReporterName ( ) const

inlineprotected

The perscribed name of the QoI storage object created in this action.

Returns: std::string The name of the StochasticReporter.

Definition at line 89 of file ParameterStudyAction.h.

89{ return "study_results"; }

Referenced by act(), and quantityOfInterestName().

◆ validParams()

InputParameters ParameterStudyAction::validParams ( )

static

Definition at line 27 of file ParameterStudyAction.C.

{
  InputParameters params = Action::validParams();
  params.addClassDescription("Builds objects to set up a basic parameter study.");
 
  // Parameters to define what we are studying
  params.addRequiredParam<FileName>(
      "input", "The input file containing the physics for the parameter study.");
  params.addRequiredParam<std::vector<std::string>>(
      "parameters", "List of parameters being perturbed for the study.");
  params.addParam<std::vector<ReporterName>>(
      "quantities_of_interest",
      "List of the reporter names (object_name/value_name) "
      "that represent the quantities of interest for the study.");
 
  // Statistics Parameters
  params.addParam<bool>(
      "compute_statistics",
      true,
      "Whether or not to compute statistics on the 'quantities_of_interest'. "
      "The default is to compute mean and standard deviation with 0.01, 0.05, 0.1, 0.9, "
      "0.95, and 0.99 confidence intervals.");
  MultiMooseEnum stats = StochasticTools::makeCalculatorEnum();
  stats = "mean stddev";
  params.addParam<MultiMooseEnum>(
      "statistics", stats, "The statistic(s) to compute for the study.");
  params.addParam<std::vector<Real>>("ci_levels",
                                     std::vector<Real>({0.01, 0.05, 0.1, 0.9, 0.95, 0.99}),
                                     "A vector of confidence levels to consider for statistics "
                                     "confidence intervals, values must be in (0, 1).");
  params.addParam<unsigned int>(
      "ci_replicates",
      1000,
      "The number of replicates to use when computing confidence level intervals for statistics.");
 
  // Parameters for the sampling scheme
  params.addRequiredParam<MooseEnum>(
      "sampling_type", samplingTypes(), "The type of sampling to use for the parameter study.");
  params.addParam<unsigned int>("seed", 0, "Random number generator initial seed");
 
  // Parameters for multi app
  MooseEnum modes(
      "normal=0 batch-reset=1 batch-restore=2 batch-keep-solution=3 batch-no-restore=4");
  params.addParam<MooseEnum>(
      "multiapp_mode",
      modes,
      "The operation mode, 'normal' creates one sub-application for each sample."
      "'batch' creates one sub-app for each processor and re-executes for each local sample. "
      "'reset' re-initializes the sub-app for every sample in the batch. "
      "'restore' does not re-initialize and instead restores to first sample's initialization. "
      "'keep-solution' re-uses the solution obtained from the first sample in the batch. "
      "'no-restore' does not restore the sub-app."
      "The default will be inferred based on the study.");
  params.addParam<unsigned int>(
      "min_procs_per_sample",
      1,
      "Minimum number of processors to give to each sample. Useful for larger, distributed mesh "
      "solves where there are memory constraints.");
  params.addParam<bool>("ignore_solve_not_converge",
                        false,
                        "True to continue main app even if a sub app's solve does not converge.");
 
  // Samplers ///////////////////////////
  // Parameters for Monte Carlo and LHS
  params.addParam<dof_id_type>(
      "num_samples", "The number of samples to generate for 'monte-carlo' and 'lhs' sampling.");
  params.addParam<MultiMooseEnum>(
      "distributions",
      distributionTypes(),
      "The types of distribution to use for 'monte-carlo' and "
      "'lhs' sampling. The number of entries defines the number of columns in the matrix.");
  // Parameters for cartesian product
  params.addParam<std::vector<Real>>(
      "linear_space_items",
      "Parameter for defining the 'cartesian-prodcut' sampling scheme. A list of triplets, each "
      "item should include the min, step size, and number of steps.");
  // Parameters for CSV sampler
  params.addParam<FileName>(
      "csv_samples_file",
      "Name of the CSV file that contains the sample matrix for 'csv' sampling.");
  params.addParam<std::vector<dof_id_type>>(
      "csv_column_indices",
      "Column indices in the CSV file to be sampled from for 'csv' sampling. Number of indices "
      "here "
      "will be the same as the number of columns per matrix.");
  params.addParam<std::vector<std::string>>(
      "csv_column_names",
      "Column names in the CSV file to be sampled from for 'csv' sampling. Number of columns names "
      "here will be the same as the number of columns per matrix.");
  // Parameters for input matrix
  params.addParam<RealEigenMatrix>("input_matrix", "Sampling matrix for 'input-matrix' sampling.");
 
  // Distributions ///////////////////////////
  // Parameters for normal distributions
  params.addParam<std::vector<Real>>("normal_mean",
                                     "Means (or expectations) of the 'normal' distributions.");
  params.addParam<std::vector<Real>>("normal_standard_deviation",
                                     "Standard deviations of the 'normal' distributions.");
  // Parameters for uniform distributions
  params.addParam<std::vector<Real>>("uniform_lower_bound",
                                     "Lower bounds for 'uniform' distributions.");
  params.addParam<std::vector<Real>>("uniform_upper_bound",
                                     "Upper bounds 'uniform' distributions.");
  // Parameters for Weibull distributions
  params.addParam<std::vector<Real>>("weibull_location",
                                     "Location parameter (a or low) for 'weibull' distributions.");
  params.addParam<std::vector<Real>>("weibull_scale",
                                     "Scale parameter (b or lambda) for 'weibull' distributions.");
  params.addParam<std::vector<Real>>("weibull_shape",
                                     "Shape parameter (c or k) for 'weibull' distributions.");
  // Parameters for lognormal distributions
  params.addParam<std::vector<Real>>(
      "lognormal_location", "The 'lognormal' distributions' location parameter (m or mu).");
  params.addParam<std::vector<Real>>(
      "lognormal_scale", "The 'lognormal' distributions' scale parameter (s or sigma).");
  // Parameters for truncated normal distributions
  params.addParam<std::vector<Real>>("tnormal_mean",
                                     "Means (or expectations) of the 'tnormal' distributions.");
  params.addParam<std::vector<Real>>("tnormal_standard_deviation",
                                     "Standard deviations of the 'tnormal' distributions.");
  params.addParam<std::vector<Real>>("tnormal_lower_bound", "'tnormal' distributions' lower bound");
  params.addParam<std::vector<Real>>("tnormal_upper_bound", "'tnormal' distributions' upper bound");
 
  // Outputting parameters
  MultiMooseEnum out_type("none=0 csv=1 json=2", "json");
  params.addParam<MultiMooseEnum>(
      "output_type",
      out_type,
      "Method in which to output sampler matrix and quantities of interest. Warning: "
      "'csv' output will not include vector-type quantities.");
  params.addParam<std::vector<ReporterValueName>>(
      "sampler_column_names",
      "Names of the sampler columns for outputting the sampling matrix. If 'parameters' are not "
      "bracketed, the default is based on these values. Otherwise, the default is based on the "
      "sampler name.");
 
  // Debug parameters
  params.addParam<bool>("show_study_objects",
                        false,
                        "Set to true to show all the objects being built by this action.");
  return params;
}

Member Data Documentation

◆ _compute_stats

const bool ParameterStudyAction::_compute_stats

private

Whether or not we are computing statistics.

Definition at line 173 of file ParameterStudyAction.h.

Referenced by act(), and ParameterStudyAction().

◆ _distributions

const MultiMooseEnum ParameterStudyAction::_distributions

private

The distributions.

Definition at line 168 of file ParameterStudyAction.h.

Referenced by act(), and ParameterStudyAction().

◆ _multiapp_mode

const unsigned int ParameterStudyAction::_multiapp_mode

private

The multiapp mode.

This is used for determining type of execution for the multiapp and the way to send the perturbed parameters

Definition at line 171 of file ParameterStudyAction.h.

Referenced by act().

◆ _parameters

const std::vector<std::string>& ParameterStudyAction::_parameters

private

The inputted parameter vector.

Definition at line 164 of file ParameterStudyAction.h.

Referenced by act(), and inferMultiAppMode().

◆ _sampling_type

const unsigned int ParameterStudyAction::_sampling_type

private

The sampling type.

Definition at line 166 of file ParameterStudyAction.h.

Referenced by act(), and ParameterStudyAction().

◆ _show_objects

const bool ParameterStudyAction::_show_objects

private

Switch to show the objects being built on console.

Definition at line 175 of file ParameterStudyAction.h.

Referenced by act().

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

stochastic_tools/include/actions/ParameterStudyAction.h
stochastic_tools/src/actions/ParameterStudyAction.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

◆ ParameterStudyAction()

Member Function Documentation

◆ act()

◆ distributionName()

◆ distributionNames()

◆ distributionParameters()

◆ distributionTypes()

◆ getDistributionParam()

◆ inferMultiAppMode()

◆ multiappControlName()

◆ multiappName()

◆ outputName()

◆ parameterTransferName()

◆ quantityOfInterestName()

◆ reporterTransferName()

◆ samplerName()

◆ samplerParameters()

◆ samplerReceiverName()

◆ samplingTypes()

◆ showObject()

◆ statisticsName()

◆ statisticsParameters()

◆ stochasticReporterName()

◆ validParams()

Member Data Documentation

◆ _compute_stats

◆ _distributions

◆ _multiapp_mode

◆ _parameters

◆ _sampling_type

◆ _show_objects