Multi Sample Action System

This system allows any object to be turned into an action that generates _N_ copies of the object using a simple registration macro like so


#include "MultiSampleAction.h"
#include "ThermalBaseTest.h"

registerMultiSampleAction("BisonTestApp", ThermalBaseTest, "add_material");

This generates a MultiSampleThermalBaseTest object. It can be registered to MOOSE syntax with another macro in the registerAll function of the app. E.g.


registerMultiSampleSyntax(ThermalBaseTest);

This will enable the following syntax

[MultiSample<<<{"href": "index.html"}>>>]
  [GeneratedMeshGenerator<<<{"href": "GeneratedMeshGenerator/index.html"}>>>]
    [mymesh]
      multi_sample_number_params<<<{"description": "List of Real value parameters to set for the generated objects"}>>> = 'xmin xmax'
      multi_sample_number_values<<<{"description": "List of Real or Integer value vectors for each parameter, multi_sample_size entries each"}>>> = "0 1.1 2.2 3.3 4.4 5.5 6.6 7.7 8.8 9.9;
                            1 2.1 3.2 4.3 5.4 6.5 7.6 8.7 9.8 10.9"
      dim<<<{"description": "The dimension of the mesh to be generated"}>>> = 2
      nx<<<{"description": "Number of elements in the X direction"}>>> = 3
      ny<<<{"description": "Number of elements in the Y direction"}>>> = 3
    []
  []

  [MultiSampleMeshCombiner<<<{"href": "MultiSampleMeshCombiner/index.html"}>>>]
    [mymesh]
    []
  []

  [DirichletBC<<<{"href": "DirichletBC/index.html"}>>>]
    [leftbc]
      multi_sample_number_params<<<{"description": "List of Real value parameters to set for the generated objects"}>>> = value
      multi_sample_number_values<<<{"description": "List of Real or Integer value vectors for each parameter, multi_sample_size entries each"}>>> = '1 2 3 4 5 6 7 8 9 10'
      value<<<{"description": "Value of the BC"}>>> = 0
      boundary<<<{"description": "The list of boundary IDs from the mesh where this object applies"}>>> = left
      variable<<<{"description": "The name of the variable that this residual object operates on"}>>> = u
    []
    [rightbc]
      multi_sample_number_params<<<{"description": "List of Real value parameters to set for the generated objects"}>>> = value
      multi_sample_number_values<<<{"description": "List of Real or Integer value vectors for each parameter, multi_sample_size entries each"}>>> = '-1 -2 -3 -4 -5 -6 -7 -8 -9 -10'
      value<<<{"description": "Value of the BC"}>>> = 0
      boundary<<<{"description": "The list of boundary IDs from the mesh where this object applies"}>>> = right
      variable<<<{"description": "The name of the variable that this residual object operates on"}>>> = u
    []
  []
[]

The example above will create 10 3x3 element meshes side by side, with the boundary_name_prefix set to mesh and the sample number, resulting in boundary names of the form mesh2_left, mesh6_bottom , etc. Using the MultiSampleMeshCombiner the results from those mesh generators are combined into a single simulation mesh.

Using the MultiSample/DirichletBC different boundary conditions are applied to each sample. Note that this action prefixes the boundary parameter in the same manner as the MultiSample/GeneratedMeshGenerator.

If several Real (or integer) valued parameters are specified in multi_sample_number_params multiple value vectors (separated by ;) must be provided in multi_sample_number_values.

Modifying object parameters programmatically

If parameters need to be modified that are not of type Real (such as the block restriction of the generated object) a functor like object can be created to programmatically assign parameter values. The MSABlockEnumerator object sets separate block restrictions for each generated object:

class MSABlockEnumerator : public MultiSampleParameterModifier
{
  // This operator sets a different block number for each generated instance.
public:
  static void modify(unsigned int i, InputParameters & params)
  {
    params.set<std::vector<SubdomainName>>("block") = {Moose::stringify(i)};
  }
};

you can explicitly provide this object, using the advanced registerMultiSampleActionCustom macro.

note

Setting the block restriction is required for MultiSample Material classes to avoid duplicate material property declaration on the same block!

Instead of MSABlockEnumerator a custom class, derived from MultiSampleParameterModifier can be provided to set parameters of arbitrary types based on the index of the generated object.

class MultiSampleParameterModifier
{
public:
  static void modify(unsigned int /*sample_index*/, InputParameters & /*params*/){};
  static void valid(InputParameters & /*params*/){};
};

void modify(unsigned int /*sample_index*/, InputParameters & /*params*/)
The modify function can be used to change any parameter value that will passed to the object created for sample sample_index. It can be used to prefix name parameters with the sample index, compute parameter values based on the sample index.
valid(InputParameters & /*params*/)
The valid function can be used to modify the set of valid input parameters returned by the underlying object's validParams function. See below for an example.

Required parameters

The MOOSE parser will complain, if the underlying objects created by a MultiSample action have required parameters that are not explicitly specified, for example because they are set using the multi_sample_number_params/multi_sample_number_values parameters. In this case the MultiSampleParameterModifier::valid(InputParameters &) interface can be used to make parameters as not required, as shown in MSASubdomainID:

class MSASubdomainID : public MultiSampleParameterModifier
{
public:
  static void modify(unsigned int i, InputParameters & params)
  {
    params.set<MeshGeneratorName>("input") += "_" + Moose::stringify(i);
    params.set<SubdomainID>("subdomain_id") = i;
  }
  static void valid(InputParameters & params)
  {
    params.makeParamNotRequired<SubdomainID>("subdomain_id");
  };
};


registerMultiSampleActionCustom("BisonTestApp", ThermalBaseTest, "add_material", MSABlockEnumerator)

Extending support for more systems

This is the compile error if an object from a yet unsupported system is registered as a MultiSampleAction:


bison/build/header_symlinks/MultiSampleAction.h:132:11: error: static assertion failed:
 =====================================================================================
 An object from an unsupported MOOSE system was supplied in registerMultiSampleAction.
 Add another if constexpr clause to MultiSampleAction<T, ParameterModifier>::act()
 with the corresponding add* call to FEProblem.
 =====================================================================================

  132 |           always_false_v<T>,
      |           ^~~~~~~~~~~~~~~~~

Should you encounter this error edit the if constexpr block in MultiSampleAction<T, ParameterModifier>::act() and add the correct FEProblemBase::add*() method for the new system you want to support.

    // add object to problem (add new systems here as needed)
    if constexpr (std::is_base_of_v<Kernel, T>)
      _problem->addKernel(type, obj_name, params);
    else if constexpr (std::is_base_of_v<AuxKernel, T>)
      _problem->addAuxKernel(type, obj_name, params);
    else if constexpr (std::is_base_of_v<BoundaryCondition, T>)
      _problem->addBoundaryCondition(type, obj_name, params);
    else if constexpr (std::is_base_of_v<Postprocessor, T>)
      _problem->addPostprocessor(type, obj_name, params);
    else if constexpr (std::is_base_of_v<Material, T>)
      _problem->addMaterial(type, obj_name, params);
    else if constexpr (std::is_base_of_v<MeshGenerator, T>)
      _app.addMeshGenerator(type, obj_name, params);
    else if constexpr (std::is_base_of_v<Action, T>)
    {
      auto action = MooseSharedNamespace::static_pointer_cast<MooseObjectAction>(
          _action_factory.create(type, obj_name, params));
      _awh.addActionBlock(action);
    }
    else
      static_assert(
          always_false_v<T>,
          "\n "
          "=====================================================================================\n "
          "An object from an unsupported MOOSE system was supplied in registerMultiSampleAction.\n "
          "Add another if constexpr clause to MultiSampleAction<T, ParameterModifier>::act()\n "
          "with the corresponding add* call to FEProblem.\n "
          "====================================================================================="
          "\n");

(test/tests/multi_sample_action/test.i)

[Mesh]
[]

[Variables]
  [u]
  []
[]

[GlobalParams]
  multi_sample_size = 10
[]

[MultiSample]
  [GeneratedMeshGenerator]
    [mymesh]
      multi_sample_number_params = 'xmin xmax'
      multi_sample_number_values = "0 1.1 2.2 3.3 4.4 5.5 6.6 7.7 8.8 9.9;
                            1 2.1 3.2 4.3 5.4 6.5 7.6 8.7 9.8 10.9"
      dim = 2
      nx = 3
      ny = 3
    []
  []

  [MultiSampleMeshCombiner]
    [mymesh]
    []
  []

  [DirichletBC]
    [leftbc]
      multi_sample_number_params = value
      multi_sample_number_values = '1 2 3 4 5 6 7 8 9 10'
      value = 0
      boundary = left
      variable = u
    []
    [rightbc]
      multi_sample_number_params = value
      multi_sample_number_values = '-1 -2 -3 -4 -5 -6 -7 -8 -9 -10'
      value = 0
      boundary = right
      variable = u
    []
  []
[]

[Kernels]
  [diff]
    type = Diffusion
    variable = u
  []
[]

[Debug]
  show_actions = true
[]

[Executioner]
  type = Steady
[]

[Outputs]
  exodus = true
[]

(src/actions/MultiSampleAction.C)

/*************************************************/
/*           DO NOT MODIFY THIS HEADER           */
/*                                               */
/*                     BISON                     */
/*                                               */
/*    (c) 2015 Battelle Energy Alliance, LLC     */
/*            ALL RIGHTS RESERVED                */
/*                                               */
/*   Prepared by Battelle Energy Alliance, LLC   */
/*     Under Contract No. DE-AC07-05ID14517      */
/*     With the U. S. Department of Energy       */
/*                                               */
/*     See COPYRIGHT for full restrictions       */
/*************************************************/

#include "MultiSampleAction.h"

// includes for derived objects
#include "DirichletBC.h"
#include "GeneratedMeshGenerator.h"
#include "SubdomainIDGenerator.h"
#include "ElementExtremeValue.h"
#include "ComputeMultipleInelasticStress.h"
#include "ParsedPostprocessor.h"
#include "Pressure.h"
#include "PressureAction.h"
#include "UO2CreepUpdate.h"

/**
 * Parameter modification functors
 */

class MultiSampleParameterModifier
{
public:
  static void modify(unsigned int /*sample_index*/, InputParameters & /*params*/){};
  static void valid(InputParameters & /*params*/){};
};

class MSABlockEnumerator : public MultiSampleParameterModifier
{
  // This operator sets a different block number for each generated instance.
public:
  static void modify(unsigned int i, InputParameters & params)
  {
    params.set<std::vector<SubdomainName>>("block") = {Moose::stringify(i)};
  }
};

class MSAOffsetAndPrefix : public MultiSampleParameterModifier
{
  // This operator prefixes boundary names and shifts IDs. It also supplys a single subdomain ID
public:
  static void modify(unsigned int i, InputParameters & params)
  {
    params.set<std::string>("boundary_name_prefix") = "mesh" + Moose::stringify(i);
    params.set<boundary_id_type>("boundary_id_offset") = i * 10;
  }
};

class MSABoundaryEnumerator : public MultiSampleParameterModifier
{
public:
  static void modify(unsigned int i, InputParameters & params)
  {
    for (auto & value : params.set<std::vector<BoundaryName>>("boundary"))
      value = "mesh" + Moose::stringify(i) + "_" + value;
  }
};

class MSAComputeMultipleInelasticStress : public MultiSampleParameterModifier
{
public:
  static void modify(unsigned int i, InputParameters & params)
  {
    for (auto & value : params.set<std::vector<MaterialName>>("inelastic_models"))
      value += "_" + Moose::stringify(i);
    params.set<std::vector<SubdomainName>>("block") = {Moose::stringify(i)};
  }
};

class MSAComputeLogPP : public MultiSampleParameterModifier
{
public:
  static void modify(unsigned int i, InputParameters & params)
  {
    const auto pp_name =
        params.get<std::vector<PostprocessorName>>("pp_names")[0] + "_" + Moose::stringify(i);
    params.set<std::vector<PostprocessorName>>("pp_names") = {pp_name};
    params.set<std::string>("function") = "log10(" + pp_name + ")";
  }
};

class MSASubdomainID : public MultiSampleParameterModifier
{
public:
  static void modify(unsigned int i, InputParameters & params)
  {
    params.set<MeshGeneratorName>("input") += "_" + Moose::stringify(i);
    params.set<SubdomainID>("subdomain_id") = i;
  }
  static void valid(InputParameters & params)
  {
    params.makeParamNotRequired<SubdomainID>("subdomain_id");
  };
};
// DOCS_MSASubdomainID_END

/**
 * Action object registration
 */

registerMultiSampleActionCustom("BisonApp",
                                GeneratedMeshGenerator,
                                "add_mesh_generator",
                                MSAOffsetAndPrefix);

registerMultiSampleActionCustom("BisonApp",
                                SubdomainIDGenerator,
                                "add_mesh_generator",
                                MSASubdomainID);

registerMultiSampleActionCustom("BisonApp", DirichletBC, "add_bc", MSABoundaryEnumerator);
registerMultiSampleActionCustom("BisonApp", PressureAction, "meta_action", MSABoundaryEnumerator);

registerMultiSampleActionCustom("BisonApp",
                                ElementExtremeValue,
                                "add_postprocessor",
                                MSABlockEnumerator);
registerMultiSampleActionCustom("BisonApp", UO2CreepUpdate, "add_material", MSABlockEnumerator);

registerMultiSampleActionCustom("BisonApp",
                                ComputeMultipleInelasticStress,
                                "add_material",
                                MSAComputeMultipleInelasticStress);

registerMultiSampleActionCustomNamed(
    "BisonApp", ParsedPostprocessor, "add_postprocessor", MSAComputeLogPP, MultiSampleComputeLog10);

namespace MultiSampleUtils
{
void
registerAll(Syntax & syntax)
{
  registerMultiSampleSyntax(GeneratedMeshGenerator);
  registerMultiSampleSyntax(SubdomainIDGenerator);
  registerMultiSampleSyntax(ElementExtremeValue);
  registerMultiSampleSyntax(ComputeMultipleInelasticStress);
  registerMultiSampleSyntax(ComputeLog10);
  registerMultiSampleSyntax(UO2CreepUpdate);
  registerMultiSampleSyntax(DirichletBC);

  registerMultiSampleSyntaxNamed(MultiSamplePressureAction, MultiSamplePressure);
}
} // namespace MultiSampleUtils

(src/actions/MultiSampleAction.C)

/*************************************************/
/*           DO NOT MODIFY THIS HEADER           */
/*                                               */
/*                     BISON                     */
/*                                               */
/*    (c) 2015 Battelle Energy Alliance, LLC     */
/*            ALL RIGHTS RESERVED                */
/*                                               */
/*   Prepared by Battelle Energy Alliance, LLC   */
/*     Under Contract No. DE-AC07-05ID14517      */
/*     With the U. S. Department of Energy       */
/*                                               */
/*     See COPYRIGHT for full restrictions       */
/*************************************************/

#include "MultiSampleAction.h"

// includes for derived objects
#include "DirichletBC.h"
#include "GeneratedMeshGenerator.h"
#include "SubdomainIDGenerator.h"
#include "ElementExtremeValue.h"
#include "ComputeMultipleInelasticStress.h"
#include "ParsedPostprocessor.h"
#include "Pressure.h"
#include "PressureAction.h"
#include "UO2CreepUpdate.h"

/**
 * Parameter modification functors
 */

class MultiSampleParameterModifier
{
public:
  static void modify(unsigned int /*sample_index*/, InputParameters & /*params*/){};
  static void valid(InputParameters & /*params*/){};
};

class MSABlockEnumerator : public MultiSampleParameterModifier
{
  // This operator sets a different block number for each generated instance.
public:
  static void modify(unsigned int i, InputParameters & params)
  {
    params.set<std::vector<SubdomainName>>("block") = {Moose::stringify(i)};
  }
};

class MSAOffsetAndPrefix : public MultiSampleParameterModifier
{
  // This operator prefixes boundary names and shifts IDs. It also supplys a single subdomain ID
public:
  static void modify(unsigned int i, InputParameters & params)
  {
    params.set<std::string>("boundary_name_prefix") = "mesh" + Moose::stringify(i);
    params.set<boundary_id_type>("boundary_id_offset") = i * 10;
  }
};

class MSABoundaryEnumerator : public MultiSampleParameterModifier
{
public:
  static void modify(unsigned int i, InputParameters & params)
  {
    for (auto & value : params.set<std::vector<BoundaryName>>("boundary"))
      value = "mesh" + Moose::stringify(i) + "_" + value;
  }
};

class MSAComputeMultipleInelasticStress : public MultiSampleParameterModifier
{
public:
  static void modify(unsigned int i, InputParameters & params)
  {
    for (auto & value : params.set<std::vector<MaterialName>>("inelastic_models"))
      value += "_" + Moose::stringify(i);
    params.set<std::vector<SubdomainName>>("block") = {Moose::stringify(i)};
  }
};

class MSAComputeLogPP : public MultiSampleParameterModifier
{
public:
  static void modify(unsigned int i, InputParameters & params)
  {
    const auto pp_name =
        params.get<std::vector<PostprocessorName>>("pp_names")[0] + "_" + Moose::stringify(i);
    params.set<std::vector<PostprocessorName>>("pp_names") = {pp_name};
    params.set<std::string>("function") = "log10(" + pp_name + ")";
  }
};

class MSASubdomainID : public MultiSampleParameterModifier
{
public:
  static void modify(unsigned int i, InputParameters & params)
  {
    params.set<MeshGeneratorName>("input") += "_" + Moose::stringify(i);
    params.set<SubdomainID>("subdomain_id") = i;
  }
  static void valid(InputParameters & params)
  {
    params.makeParamNotRequired<SubdomainID>("subdomain_id");
  };
};
// DOCS_MSASubdomainID_END

/**
 * Action object registration
 */

registerMultiSampleActionCustom("BisonApp",
                                GeneratedMeshGenerator,
                                "add_mesh_generator",
                                MSAOffsetAndPrefix);

registerMultiSampleActionCustom("BisonApp",
                                SubdomainIDGenerator,
                                "add_mesh_generator",
                                MSASubdomainID);

registerMultiSampleActionCustom("BisonApp", DirichletBC, "add_bc", MSABoundaryEnumerator);
registerMultiSampleActionCustom("BisonApp", PressureAction, "meta_action", MSABoundaryEnumerator);

registerMultiSampleActionCustom("BisonApp",
                                ElementExtremeValue,
                                "add_postprocessor",
                                MSABlockEnumerator);
registerMultiSampleActionCustom("BisonApp", UO2CreepUpdate, "add_material", MSABlockEnumerator);

registerMultiSampleActionCustom("BisonApp",
                                ComputeMultipleInelasticStress,
                                "add_material",
                                MSAComputeMultipleInelasticStress);

registerMultiSampleActionCustomNamed(
    "BisonApp", ParsedPostprocessor, "add_postprocessor", MSAComputeLogPP, MultiSampleComputeLog10);

namespace MultiSampleUtils
{
void
registerAll(Syntax & syntax)
{
  registerMultiSampleSyntax(GeneratedMeshGenerator);
  registerMultiSampleSyntax(SubdomainIDGenerator);
  registerMultiSampleSyntax(ElementExtremeValue);
  registerMultiSampleSyntax(ComputeMultipleInelasticStress);
  registerMultiSampleSyntax(ComputeLog10);
  registerMultiSampleSyntax(UO2CreepUpdate);
  registerMultiSampleSyntax(DirichletBC);

  registerMultiSampleSyntaxNamed(MultiSamplePressureAction, MultiSamplePressure);
}
} // namespace MultiSampleUtils

(src/actions/MultiSampleAction.C)

/*************************************************/
/*           DO NOT MODIFY THIS HEADER           */
/*                                               */
/*                     BISON                     */
/*                                               */
/*    (c) 2015 Battelle Energy Alliance, LLC     */
/*            ALL RIGHTS RESERVED                */
/*                                               */
/*   Prepared by Battelle Energy Alliance, LLC   */
/*     Under Contract No. DE-AC07-05ID14517      */
/*     With the U. S. Department of Energy       */
/*                                               */
/*     See COPYRIGHT for full restrictions       */
/*************************************************/

#include "MultiSampleAction.h"

// includes for derived objects
#include "DirichletBC.h"
#include "GeneratedMeshGenerator.h"
#include "SubdomainIDGenerator.h"
#include "ElementExtremeValue.h"
#include "ComputeMultipleInelasticStress.h"
#include "ParsedPostprocessor.h"
#include "Pressure.h"
#include "PressureAction.h"
#include "UO2CreepUpdate.h"

/**
 * Parameter modification functors
 */

class MultiSampleParameterModifier
{
public:
  static void modify(unsigned int /*sample_index*/, InputParameters & /*params*/){};
  static void valid(InputParameters & /*params*/){};
};

class MSABlockEnumerator : public MultiSampleParameterModifier
{
  // This operator sets a different block number for each generated instance.
public:
  static void modify(unsigned int i, InputParameters & params)
  {
    params.set<std::vector<SubdomainName>>("block") = {Moose::stringify(i)};
  }
};

class MSAOffsetAndPrefix : public MultiSampleParameterModifier
{
  // This operator prefixes boundary names and shifts IDs. It also supplys a single subdomain ID
public:
  static void modify(unsigned int i, InputParameters & params)
  {
    params.set<std::string>("boundary_name_prefix") = "mesh" + Moose::stringify(i);
    params.set<boundary_id_type>("boundary_id_offset") = i * 10;
  }
};

class MSABoundaryEnumerator : public MultiSampleParameterModifier
{
public:
  static void modify(unsigned int i, InputParameters & params)
  {
    for (auto & value : params.set<std::vector<BoundaryName>>("boundary"))
      value = "mesh" + Moose::stringify(i) + "_" + value;
  }
};

class MSAComputeMultipleInelasticStress : public MultiSampleParameterModifier
{
public:
  static void modify(unsigned int i, InputParameters & params)
  {
    for (auto & value : params.set<std::vector<MaterialName>>("inelastic_models"))
      value += "_" + Moose::stringify(i);
    params.set<std::vector<SubdomainName>>("block") = {Moose::stringify(i)};
  }
};

class MSAComputeLogPP : public MultiSampleParameterModifier
{
public:
  static void modify(unsigned int i, InputParameters & params)
  {
    const auto pp_name =
        params.get<std::vector<PostprocessorName>>("pp_names")[0] + "_" + Moose::stringify(i);
    params.set<std::vector<PostprocessorName>>("pp_names") = {pp_name};
    params.set<std::string>("function") = "log10(" + pp_name + ")";
  }
};

class MSASubdomainID : public MultiSampleParameterModifier
{
public:
  static void modify(unsigned int i, InputParameters & params)
  {
    params.set<MeshGeneratorName>("input") += "_" + Moose::stringify(i);
    params.set<SubdomainID>("subdomain_id") = i;
  }
  static void valid(InputParameters & params)
  {
    params.makeParamNotRequired<SubdomainID>("subdomain_id");
  };
};
// DOCS_MSASubdomainID_END

/**
 * Action object registration
 */

registerMultiSampleActionCustom("BisonApp",
                                GeneratedMeshGenerator,
                                "add_mesh_generator",
                                MSAOffsetAndPrefix);

registerMultiSampleActionCustom("BisonApp",
                                SubdomainIDGenerator,
                                "add_mesh_generator",
                                MSASubdomainID);

registerMultiSampleActionCustom("BisonApp", DirichletBC, "add_bc", MSABoundaryEnumerator);
registerMultiSampleActionCustom("BisonApp", PressureAction, "meta_action", MSABoundaryEnumerator);

registerMultiSampleActionCustom("BisonApp",
                                ElementExtremeValue,
                                "add_postprocessor",
                                MSABlockEnumerator);
registerMultiSampleActionCustom("BisonApp", UO2CreepUpdate, "add_material", MSABlockEnumerator);

registerMultiSampleActionCustom("BisonApp",
                                ComputeMultipleInelasticStress,
                                "add_material",
                                MSAComputeMultipleInelasticStress);

registerMultiSampleActionCustomNamed(
    "BisonApp", ParsedPostprocessor, "add_postprocessor", MSAComputeLogPP, MultiSampleComputeLog10);

namespace MultiSampleUtils
{
void
registerAll(Syntax & syntax)
{
  registerMultiSampleSyntax(GeneratedMeshGenerator);
  registerMultiSampleSyntax(SubdomainIDGenerator);
  registerMultiSampleSyntax(ElementExtremeValue);
  registerMultiSampleSyntax(ComputeMultipleInelasticStress);
  registerMultiSampleSyntax(ComputeLog10);
  registerMultiSampleSyntax(UO2CreepUpdate);
  registerMultiSampleSyntax(DirichletBC);

  registerMultiSampleSyntaxNamed(MultiSamplePressureAction, MultiSamplePressure);
}
} // namespace MultiSampleUtils

(include/actions/MultiSampleAction.h)

/*************************************************/
/*           DO NOT MODIFY THIS HEADER           */
/*                                               */
/*                     BISON                     */
/*                                               */
/*    (c) 2015 Battelle Energy Alliance, LLC     */
/*            ALL RIGHTS RESERVED                */
/*                                               */
/*   Prepared by Battelle Energy Alliance, LLC   */
/*     Under Contract No. DE-AC07-05ID14517      */
/*     With the U. S. Department of Energy       */
/*                                               */
/*     See COPYRIGHT for full restrictions       */
/*************************************************/

#pragma once

#include "Action.h"
#include "MooseObjectAction.h"
#include "Registry.h"
#include "FEProblemBase.h"

#include <type_traits>

class Kernel;
class BoundaryCondition;
class Postprocessor;
template <typename>
class AuxKernelTempl;
typedef class AuxKernelTempl<Real> AuxKernel;

/**
 * Default Parameter modification operator for MultiSampleAction derived classes.
 * This operator does not modify any parameters.
 */
class MSANullEnumerator
{
public:
  void operator()(unsigned int, InputParameters &) {}
};

template <class T, class ParameterModifier>
class MultiSampleAction : public Action
{
public:
  static InputParameters validParams();

  MultiSampleAction(const InputParameters & parameters);

  virtual void act() override;

private:
  template <class>
  inline static constexpr bool always_false_v = false;

  template <typename P, typename V>
  bool trySetInternal(InputParameters & params, const std::string & name, const V & value);
  template <typename... Ps, typename V>
  bool trySet(InputParameters & params, const std::string & name, const V & value)
  {
    return (trySetInternal<Ps>(params, name, value) || ...);
  }
};

template <class T, class ParameterModifier>
InputParameters
MultiSampleAction<T, ParameterModifier>::validParams()
{
  auto params = T::validParams();
  ParameterModifier::valid(params);
  params.template addRequiredParam<unsigned int>("multi_sample_size",
                                                 "Number of objects to create");
  params.template addParam<std::vector<std::string>>(
      "multi_sample_number_params",
      "List of Real value parameters to set for the generated objects");
  params.template addParam<std::vector<std::vector<Real>>>(
      "multi_sample_number_values",
      "List of Real or Integer value vectors for each parameter, multi_sample_size entries each");
  params.template addParam<std::vector<std::string>>(
      "multi_sample_string_params",
      "List of Real value parameters to set for the generated objects");
  params.template addParam<std::vector<std::vector<std::string>>>(
      "multi_sample_string_values",
      "List of string vectors for each parameter, multi_sample_size entries each");
  return params;
}

template <class T, class ParameterModifier>
MultiSampleAction<T, ParameterModifier>::MultiSampleAction(const InputParameters & parameters)
  : Action(parameters)
{
}

template <class T, class ParameterModifier>
void
MultiSampleAction<T, ParameterModifier>::act()
{
  const auto param_number_values = this->template getParam<std::string, std::vector<Real>>(
      "multi_sample_number_params", "multi_sample_number_values");
  const auto param_string_values = this->template getParam<std::string, std::vector<std::string>>(
      "multi_sample_string_params", "multi_sample_string_values");
  const auto sample_size = getParam<unsigned int>("multi_sample_size");

  for (const auto i : make_range(sample_size))
  {
    const auto type = Registry::getClassName<T>();

    // setup parameters
    auto params = emptyInputParameters();
    if constexpr (std::is_base_of_v<Action, T>)
      params = _action_factory.getValidParams(type);
    else
      params = _factory.getValidParams(type);
    params.applyParameters(parameters());

    // modify parameters programmatically
    ParameterModifier::modify(i, params);

    // modify params using user supplied tables
    for (const auto & [param, values] : param_number_values)
      if (values.size() != sample_size)
        paramError("multi_sample_number_values",
                   "The vector for multi_sample_number_params entry '",
                   param,
                   "' has ",
                   values.size(),
                   " entries, but should have multi_sample_size=",
                   sample_size,
                   " entries.");
      else if (!trySet<Real, int, unsigned int, short int, unsigned short>(
                   params, param, values[i]))
        paramError("multi_sample_number_params",
                   "This '",
                   type,
                   "' object does not have a Real or integer value parameter '",
                   param,
                   "'.");

    for (const auto & [param, values] : param_string_values)
      if (values.size() != sample_size)
        paramError("multi_sample_string_values",
                   "The vector for multi_sample_string_params entry '",
                   param,
                   "' has ",
                   values.size(),
                   " entries, but should have multi_sample_size=",
                   sample_size,
                   " entries.");
      else if (!trySet<std::string,
                       FileName,
                       SubdomainName,
                       BoundaryName,
                       FunctionName,
                       ParsedFunctionExpression>(params, param, values[i]))
        paramError("multi_sample_string_params",
                   "This '",
                   type,
                   "' object does not have a string value parameter '",
                   param,
                   "'.");

    // range check the generated parameters
    params.checkParams(parameters().blockFullpath());

    // object name
    const auto obj_name = name() + "_" + Moose::stringify(i);

    // DOCS_ADD_OBJECT_BEGIN
    // add object to problem (add new systems here as needed)
    if constexpr (std::is_base_of_v<Kernel, T>)
      _problem->addKernel(type, obj_name, params);
    else if constexpr (std::is_base_of_v<AuxKernel, T>)
      _problem->addAuxKernel(type, obj_name, params);
    else if constexpr (std::is_base_of_v<BoundaryCondition, T>)
      _problem->addBoundaryCondition(type, obj_name, params);
    else if constexpr (std::is_base_of_v<Postprocessor, T>)
      _problem->addPostprocessor(type, obj_name, params);
    else if constexpr (std::is_base_of_v<Material, T>)
      _problem->addMaterial(type, obj_name, params);
    else if constexpr (std::is_base_of_v<MeshGenerator, T>)
      _app.addMeshGenerator(type, obj_name, params);
    else if constexpr (std::is_base_of_v<Action, T>)
    {
      auto action = MooseSharedNamespace::static_pointer_cast<MooseObjectAction>(
          _action_factory.create(type, obj_name, params));
      _awh.addActionBlock(action);
    }
    else
      static_assert(
          always_false_v<T>,
          "\n "
          "=====================================================================================\n "
          "An object from an unsupported MOOSE system was supplied in registerMultiSampleAction.\n "
          "Add another if constexpr clause to MultiSampleAction<T, ParameterModifier>::act()\n "
          "with the corresponding add* call to FEProblem.\n "
          "====================================================================================="
          "\n");
    // DOCS_ADD_OBJECT_END
  }
}

template <class T, class ParameterModifier>
template <typename P, typename V>
bool
MultiSampleAction<T, ParameterModifier>::trySetInternal(InputParameters & params,
                                                        const std::string & name,
                                                        const V & value)
{
  if (!params.have_parameter<P>(name))
    return false;
  params.set<P>(name) = static_cast<P>(value);
  return true;
}

// helper macros

//
// Use
//   registerMultiSampleAction(app, ObjectName, task);
// In a .C file in your app and then add
//   registerMultiSampleSyntax(ObjectName);
// to the app's registerAll function.
//

#define registerMultiSampleActionCustomNamed(app, name, task, parameter_modifier, action_name)     \
  class action_name : public MultiSampleAction<name, parameter_modifier>                           \
  {                                                                                                \
  public:                                                                                          \
    using MultiSampleAction<name, parameter_modifier>::MultiSampleAction;                          \
    using MultiSampleAction<name, parameter_modifier>::validParams;                                \
  };                                                                                               \
  registerMooseAction(app, action_name, task)

#define registerMultiSampleActionCustom(app, name, task, parameter_modifier)                       \
  registerMultiSampleActionCustomNamed(app, name, task, parameter_modifier, MultiSample##name)

#define registerMultiSampleAction(app, name, task)                                                 \
  registerMultiSampleActionCustom(app, name, task, MSANullEnumerator)

#define registerMultiSampleSyntax(name) registerMultiSampleSyntaxNamed(MultiSample##name, name)

#define registerMultiSampleSyntaxNamed(name, syntax)                                               \
  registerSyntax(stringifyName(name), "MultiSample/" #syntax "/*")

namespace MultiSampleUtils
{
void registerAll(Syntax & syntax);
}

Modifying object parameters programmatically
Extending support for more systems