SingleParameterInverseSolveAction

Overview

The SingleParameterInverseSolve action generates a complete fixed-point inverse-solve workflow from a single block, so users do not have to hand-write the coupled MultiApps, Transfers, Postprocessors, Convergence, and Controls blocks.

It recovers a single time-dependent scalar parameter that drives a transient forward model to match a target Function of time. The parameter is genuinely time-dependent, but it can only be recovered at the time steps actually taken: at each step the workflow performs one independent scalar root find for the value that makes the forward output match the target at that step, starting from the previous step's converged value. The recovered history is therefore the sequence of samples , and it depends on the time discretization – because the forward model carries state from one step to the next, refining dt changes the recovered values.

The forward model runs as a transient sub-application (a TransientMultiApp): the matched quantity evolves in time and each step builds on the previous one, so the model must advance step by step and be re-solved for each trial parameter inside the fixed-point (Picard) iteration. The main application drives that loop – it holds the parameter, transfers it down, reads the output back, and updates the parameter through the inversion Control. It may also run its own physics, but need not; the minimal setup only requires a non-empty nonlinear system on the main application.

This is deliberately not framed as an Optimize solve. Optimize derives from Steady: one objective evaluation runs the entire transient, and the full parameter history is recovered simultaneously as a single optimization problem. SingleParameterInverseSolve instead performs one independent one-dimensional root find per time step, nested in the executioner's existing fixed-point (Picard) loop, and needs no additional application instances. The step-by-step approach is applicable whenever the parameter can be recovered one step at a time, which holds when the forward model advances step by step and each step depends only on the parameter at that step.

The method parameter selects the update rule:

• secant (default) — solve through SecantInversionControl.

• newton — solve through NewtonInversionControl.

multiapp_fixed_point_convergence = single_parameter_inverse_solve_convergence

Example Input Syntax

# Inverse solve driven by the `SingleParameterInverseSolve` action.
#
# Equivalent to the hand-written secant.i workflow: finds p(t) so the forward output u(t) matches
# target f(t) = t^2. Expected param_value = 1, 3, 5, 7, 9.
#
# The block generates the forward MultiApp, the transfers, the working postprocessors, the
# convergence, and the inversion Control. The only remaining wiring is the one required executioner
# line pointing at the generated convergence.
#
# The tests reuse this input with cli_args to reach the Newton method, the accept-on-max and
# absolute-tolerance paths, and the error raised when the executioner line is wrong.

# Supplies the Mesh and a Problem that skips the nonlinear-system check, so this orchestrating
# main app needs no variables of its own.
[Optimization<<<{"href": "../../syntax/Optimization/index.html"}>>>]
[]

[Functions<<<{"href": "../../syntax/Functions/index.html"}>>>]
  [target_fn]
    type = ParsedFunction<<<{"description": "Function created by parsing a string", "href": "../functions/MooseParsedFunction.html"}>>>
    expression<<<{"description": "The user defined function."}>>> = 't^2'
  []
[]

[SingleParameterInverseSolve<<<{"href": "../../syntax/SingleParameterInverseSolve/index.html"}>>>]
  method<<<{"description": "Inversion update method."}>>> = secant
  forward_input<<<{"description": "Forward-model sub-app input file."}>>> = forward_linear.i
  sub_parameter_postprocessor<<<{"description": "Sub-app postprocessor that receives the parameter value."}>>> = param_pp
  sub_output_postprocessor<<<{"description": "Sub-app postprocessor holding the output to match the target."}>>> = output_pp
  target_function<<<{"description": "Target output f(t)."}>>> = target_fn
  initial_parameter<<<{"description": "Initial guess for the parameter."}>>> = 1.0
  result_postprocessor<<<{"description": "Name of the created postprocessor holding the converged parameter (output to CSV)."}>>> = param_value
[]

[Executioner<<<{"href": "../../syntax/Executioner/index.html"}>>>]
  type = Transient
  num_steps = 5
  dt = 1
  solve_type = NEWTON
  multiapp_fixed_point_convergence = single_parameter_inverse_solve_convergence
[]

[Outputs<<<{"href": "../../syntax/Outputs/index.html"}>>>]
  csv<<<{"description": "Output the scalar variable and postprocessors to a *.csv file using the default CSV output."}>>> = true
[]

Input Parameters