Generates the full fixed-point inverse-solve workflow for a single scalar parameter from one SingleParameterInverseSolve block: a forward-model TransientMultiApp, the parameter/output postprocessor transfers, the working and result postprocessors, a PostprocessorConvergence, and either a SecantInversionControl or a NewtonInversionControl (selected by the 'method' parameter). More...

#include <SingleParameterInverseSolveAction.h>

Inheritance diagram for SingleParameterInverseSolveAction:

[legend]

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	SingleParameterInverseSolveAction (const InputParameters &parameters)

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 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
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
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 const hit::Node *	getHitNode (const InputParameters &params)

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

Private Attributes
const ParallelParamObject &	_parent

MooseApp &	_meta_data_app

const MooseObject *const	_meta_data_object

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

Detailed Description

Generates the full fixed-point inverse-solve workflow for a single scalar parameter from one SingleParameterInverseSolve block: a forward-model TransientMultiApp, the parameter/output postprocessor transfers, the working and result postprocessors, a PostprocessorConvergence, and either a SecantInversionControl or a NewtonInversionControl (selected by the 'method' parameter).

The user only additionally needs to point the executioner at the generated convergence ('multiapp_fixed_point_convergence = <block>_convergence'), which enables the Picard loop.

Definition at line 22 of file SingleParameterInverseSolveAction.h.

Constructor & Destructor Documentation

◆ SingleParameterInverseSolveAction()

SingleParameterInverseSolveAction::SingleParameterInverseSolveAction ( const InputParameters & parameters )

Definition at line 80 of file SingleParameterInverseSolveAction.C.

  : Action(parameters)
{
}

Member Function Documentation

◆ act()

void SingleParameterInverseSolveAction::act ( )

overridevirtual

Implements Action.

Definition at line 87 of file SingleParameterInverseSolveAction.C.

{
  // Derive the generated-object name prefix in snake_case (e.g. single_parameter_inverse_solve).
  const std::string p = MooseUtils::camelCaseToUnderscore(name());
  const bool newton = getParam<MooseEnum>("method") == "newton";
  const std::string residual = p + "_residual";
  const PostprocessorName result = getParam<PostprocessorName>("result_postprocessor");
 
  if (_current_task == "add_multi_app")
  {
    auto ps = _factory.getValidParams("TransientMultiApp");
    ps.set<std::vector<FileName>>("input_files") = {getParam<FileName>("forward_input")};
    // Load-bearing: the sub-app must re-solve on every fixed-point iteration (each begins a
    // TIMESTEP_BEGIN), so the control sees a fresh forward output for each trial parameter.
    ps.set<ExecFlagEnum>("execute_on") = {EXEC_TIMESTEP_BEGIN};
    _problem->addMultiApp("TransientMultiApp", p + "_forward", ps);
  }
  else if (_current_task == "add_transfer")
  {
    auto t1 = _factory.getValidParams("MultiAppPostprocessorTransfer");
    t1.set<MultiAppName>("to_multi_app") = p + "_forward";
    t1.set<PostprocessorName>("from_postprocessor") = p + "_param";
    t1.set<PostprocessorName>("to_postprocessor") =
        getParam<PostprocessorName>("sub_parameter_postprocessor");
    _problem->addTransfer("MultiAppPostprocessorTransfer", p + "_to_forward", t1);
 
    auto t2 = _factory.getValidParams("MultiAppPostprocessorTransfer");
    t2.set<MultiAppName>("from_multi_app") = p + "_forward";
    t2.set<PostprocessorName>("from_postprocessor") =
        getParam<PostprocessorName>("sub_output_postprocessor");
    t2.set<PostprocessorName>("to_postprocessor") = p + "_output";
    t2.set<MooseEnum>("reduction_type") = "average";
    _problem->addTransfer("MultiAppPostprocessorTransfer", p + "_from_forward", t2);
  }
  else if (_current_task == "add_postprocessor")
  {
    const std::vector<OutputName> none = {"none"};
 
    // Working parameter guess (transferred to the sub-app, read and written by the control).
    auto pp = _factory.getValidParams("Receiver");
    pp.set<Real>("default") = getParam<Real>("initial_parameter");
    pp.set<std::vector<OutputName>>("outputs") = none;
    _problem->addPostprocessor("Receiver", p + "_param", pp);
 
    // Sub-app output (filled by the FROM transfer).
    auto po = _factory.getValidParams("Receiver");
    po.set<std::vector<OutputName>>("outputs") = none;
    _problem->addPostprocessor("Receiver", p + "_output", po);
 
    // Published converged parameter (the CSV output of interest).
    auto pr = _factory.getValidParams("Receiver");
    pr.set<Real>("default") = 0.0;
    _problem->addPostprocessor("Receiver", result, pr);
 
    // Convergence residual, written by the control each iteration (normalized so convergence is
    // declared at a fixed tolerance of 1). Large default so a step is never "converged" pre-solve.
    auto pres = _factory.getValidParams("Receiver");
    pres.set<Real>("default") = 1e30;
    pres.set<std::vector<OutputName>>("outputs") = none;
    _problem->addPostprocessor("Receiver", residual, pres);
  }
  else if (_current_task == "add_convergence")
  {
    auto pc = _factory.getValidParams("PostprocessorConvergence");
    pc.set<PostprocessorName>("postprocessor") = residual;
    pc.set<Real>("tolerance") = 1.0;
    pc.set<unsigned int>("max_iterations") = getParam<unsigned int>("max_iterations");
    pc.set<bool>("converge_at_max_iterations") = getParam<bool>("accept_on_max_iterations");
    pc.set<bool>("verbose") = getParam<bool>("verbose");
    _problem->addConvergence("PostprocessorConvergence", p + "_convergence", pc);
  }
  else if (_current_task == "add_control")
  {
    // The action cannot enable the fixed-point loop itself (that is frozen when the executioner is
    // constructed, before actions run), but by this task the executioner's convergence choice is
    // finalized, so verify the user pointed it at this action's convergence. Otherwise the loop is
    // disabled or driven by a different convergence and the inverse solve silently would not run.
    const std::string conv_name = p + "_convergence";
    if (!_problem->hasSetMultiAppFixedPointConvergenceName() ||
        _problem->getMultiAppFixedPointConvergenceName() != conv_name)
    {
      // Distinguish three states for the error, since "set" alone conflates two very different
      // user experiences: hasSetMultiAppFixedPointConvergenceName() is also true when the user
      // wrote nothing and MOOSE silently defaulted the name
      // (needToAddDefaultMultiAppFixedPointConvergence() is how that default path is told apart
      // from the user actually naming a convergence). Each branch supplies its own complete
      // trailing sentence, since the three cases do not share a sentence structure.
      std::string current;
      if (!_problem->hasSetMultiAppFixedPointConvergenceName())
        // Reachable when the executioner never builds a FixedPointSolve at all (e.g. an
        // Executor-based executioner), so no name -- default or otherwise -- was ever assigned.
        current = "It is currently not set.";
      else if (_problem->needToAddDefaultMultiAppFixedPointConvergence())
        current = "No 'multiapp_fixed_point_convergence' was given, so MOOSE created a default "
                  "one instead.";
      else
        current =
            "It is currently set to '" + _problem->getMultiAppFixedPointConvergenceName() + "'.";
 
      mooseError("[",
                 p,
                 "] requires the executioner to use its generated convergence to enable and drive "
                 "the fixed-point loop. Add\n\n    multiapp_fixed_point_convergence = ",
                 conv_name,
                 "\n\nto the [Executioner] block. ",
                 current);
    }
 
    const std::string ctype = newton ? "NewtonInversionControl" : "SecantInversionControl";
    auto pctl = _factory.getValidParams(ctype);
    pctl.set<PostprocessorName>("output_postprocessor") = p + "_output";
    pctl.set<PostprocessorName>("parameter_postprocessor") = p + "_param";
    pctl.set<PostprocessorName>("converged_parameter_postprocessor") = result;
    pctl.set<PostprocessorName>("residual_postprocessor") = residual;
    pctl.set<FunctionName>("target_function") = getParam<FunctionName>("target_function");
    pctl.set<Real>("absolute_tolerance") = getParam<Real>("absolute_tolerance");
    pctl.set<Real>("relative_tolerance") = getParam<Real>("relative_tolerance");
    if (newton)
      pctl.set<Real>("parameter_delta") = getParam<Real>("perturbation");
    else
      pctl.set<Real>("initial_delta") = getParam<Real>("perturbation");
 
    pctl.addPrivateParam<FEProblemBase *>("_fe_problem_base", _problem.get());
    auto control = _factory.create<Control>(ctype, p + "_control", pctl);
    _problem->getControlWarehouse().addObject(control);
  }
}

◆ validParams()

InputParameters SingleParameterInverseSolveAction::validParams ( )

static

Definition at line 24 of file SingleParameterInverseSolveAction.C.

{
  InputParameters params = Action::validParams();
  params.addClassDescription(
      "Generates the full fixed-point inverse-solve workflow (forward sub-app, transfers, "
      "postprocessors, convergence, and a secant or Newton inversion control) from a single "
      "block.");
 
  MooseEnum method("secant newton", "secant");
  params.addParam<MooseEnum>("method", method, "Inversion update method.");
  params.addRequiredParam<FileName>("forward_input", "Forward-model sub-app input file.");
  params.addRequiredParam<PostprocessorName>(
      "sub_parameter_postprocessor", "Sub-app postprocessor that receives the parameter value.");
  params.addRequiredParam<PostprocessorName>(
      "sub_output_postprocessor", "Sub-app postprocessor holding the output to match the target.");
  params.addRequiredParam<FunctionName>("target_function", "Target output f(t).");
  params.addParam<Real>("initial_parameter", 1.0, "Initial guess for the parameter.");
  params.addRangeCheckedParam<Real>(
      "perturbation",
      1e-3,
      "perturbation>0",
      "Perturbation used to seed/compute the derivative (initial_delta for secant, "
      "parameter_delta for newton).");
  params.addRangeCheckedParam<Real>("absolute_tolerance",
                                    1e-8,
                                    "absolute_tolerance>0",
                                    "Absolute tolerance on |output - target|.");
  params.addRangeCheckedParam<Real>(
      "relative_tolerance",
      1e-6,
      "relative_tolerance>0",
      "Relative tolerance on |output - target|, relative to |target|.");
  params.addParam<unsigned int>(
      "max_iterations",
      50,
      "Maximum number of fixed-point iterations on the generated convergence. With method=newton "
      "each Newton update consumes two fixed-point iterations (a base and a perturbed solve), so "
      "the effective number of Newton updates is about half this value.");
  params.addParam<bool>(
      "accept_on_max_iterations",
      false,
      "If true, accept the current estimate when the fixed-point loop reaches max_iterations "
      "instead of diverging, cutting the time step, and erroring.");
  params.addParam<PostprocessorName>(
      "result_postprocessor",
      "inverse_parameter",
      "Name of the created postprocessor holding the converged parameter (output to CSV).");
  params.addParam<bool>(
      "verbose",
      false,
      "Forwarded to the generated convergence: if true, it prints per-iteration convergence "
      "information, including the accept-on-max decision when accept_on_max_iterations is set.");
 
  return params;
}

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

optimization/include/actions/SingleParameterInverseSolveAction.h
optimization/src/actions/SingleParameterInverseSolveAction.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