#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

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

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

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

Public Attributes
const ConsoleStream	_console

Static Public Attributes
static constexpr auto	SYSTEM

static constexpr auto	NAME

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const std::string	_type

const std::string	_name

const InputParameters &	_pars

Factory &	_factory

ActionFactory &	_action_factory

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

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

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

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

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

const unsigned int	_sampling_type
	The sampling type. More...

const MultiMooseEnum	_distributions
	The distributions. More...

const unsigned int	_multiapp_mode
	The multiapp mode. More...

const bool	_compute_stats
	Whether or not we are computing statistics. More...

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

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;
       // 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 608 of file ParameterStudyAction.C.

Referenced by act(), and distributionNames().

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

◆ distributionNames()

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

protected

Definition at line 614 of file ParameterStudyAction.C.

Referenced by act().

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

◆ 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 685 of file ParameterStudyAction.C.

Referenced by ParameterStudyAction().

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

◆ distributionTypes()

MultiMooseEnum ParameterStudyAction::distributionTypes ( )

static

Return an enum of available distributions for the study.

Definition at line 254 of file ParameterStudyAction.C.

Referenced by act(), and validParams().

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

◆ 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 703 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));
   hit::explode(root.get());
 
   // 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.

Referenced by act().

68 { return "study_multiapp_control"; }

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

Referenced by act().

54 { return "study_app"; }

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

Referenced by act().

97 { return type; }

Action::type

const std::string & type() const

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

Referenced by act().

75 { return "study_parameter_transfer"; }

◆ 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 623 of file ParameterStudyAction.C.

Referenced by act().

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

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

Referenced by act().

82 { return "study_qoi_transfer"; }

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

Referenced by act().

47 { return "study_sampler"; }

◆ 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 674 of file ParameterStudyAction.C.

Referenced by ParameterStudyAction().

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

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

Referenced by act().

61 { return "study_receiver"; }

◆ samplingTypes()

MooseEnum ParameterStudyAction::samplingTypes ( )

static

Return an enum of available sampling types for the study.

Definition at line 248 of file ParameterStudyAction.C.

Referenced by validParams().

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

◆ 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 629 of file ParameterStudyAction.C.

Referenced by act().

 {
   // Output basic information
   std::string base_type = params.have_parameter<std::string>("_moose_base")
                               ? params.get<std::string>("_moose_base")
                               : "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;
 }

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

Referenced by act().

112 { return "study_statistics"; }

◆ statisticsParameters()

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

staticprivate

List of parameters that are only associated with computing statistics.

Definition at line 697 of file ParameterStudyAction.C.

Referenced by ParameterStudyAction().

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

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

Referenced by act(), and quantityOfInterestName().

89 { return "study_results"; }

◆ 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