MultiAppGeneralFieldFunctorTransfer

Transfers functor data at the MultiApp position by evaluating the functor inside its domain of definition and extrapolating with a user-selected behavior outside

This transfer can use any Functor to compute the values to transfer. This provides great flexibility in how to compute source values, but also creates difficults, notably because both the interpolation and extrapolation behavior of a functor depend on its particular implementation.

Interpolation behavior

When a target point (see MultiAppGeneralFieldTransfer for how target points for transfers are chosen) is located inside a source application domain by the point locator associated with the source mesh, the source functor is evaluated.

If the point locator only found a single element, the functor is evaluated with an ElemPointArg (see Functor documentation for definition) with that element and the target point in the source application frame of reference. If multiple elements are found, the functor is evaluated with each element, and a arithmetic average of all evaluations is returned.

note

If multiple source child applications are overlapping for the same target point, then a source value conflict should be detected and a warning is output.

Extrapolation behavior options

The following options are available when the target point is outside the source application's mesh or outside the source functor's subdomain restriction of the mesh:

"extrapolation_behavior" = flat will return the "extrapolation_constant" specified by the user (defaults to -1).
"extrapolation_behavior" = nearest-node will return the functor value at the nearest node on the boundary of the functor's domain of definition. If the functor is not defined at nodes, this will likely cause an error when pre-computing these values.
"extrapolation_behavior" = nearest-elem will return the functor value at the nearest element on the boundary of the functor's domain of definition. If the functor is not defined at elements (rare), this will likely cause an error when pre-computing these values.
"extrapolation_behavior" = evaluate_oob will evaluate the functor with a null element and the target point in the source application frame of reference. Some functors, such as spatial user objects or functions, can often be evaluate out of bounds (oob). Others, like variables, will error on such evaluation.

Source and target spatial restrictions

All the spatial restrictions implemented in MultiAppGeneralFieldTransfer are available to this class. The block restriction of the source functors are respected in that the functors are never evaluated outside their block restriction, unless "extrapolation_behavior" is set to evaluate_oob.

Caveats and known numerical issues

The items below are known difficulties shared with the MultiAppGeneralFieldNearestLocationTransfer. The MultiAppGeneralFieldFunctorTransfer.md is not affected by these issues when interpolating values (where the source and target domains overlap) because it does not use a nearest-location there, it simply evaluates the functors. However, when extrapolating, it uses the same algorithm as MultiAppGeneralFieldNearestLocationTransfer and thus is subject to the same caveats.

warning

Nearest-location algorithms are vulnerable to finite precision round-offs if multiple sources are exactly at the same distance from a given target. This can affect repeatability of results. Use the "search_value_conflicts" parameter to uncover these issues.

The "num_nearest_points" allows for a simple geometric mixing of extrapolation values of several nearest nodes/elements to the target points. This mixing is performed in every origin problem independently, values from different child applications (or from different processes within each application) will not be mixed together.

warning

If "num_nearest_points" is more than 1, the results will differ in parallel if the target locations are near the parallel process boundaries on the origin app mesh. Use the "output_process_domains" parameter to examine process boundaries on Exodus/Nemesis output.

Example Input File Syntax

In this example, a MultiAppGeneralFieldFunctorTransfer is used to transfervalues from a spatial user object to_sub from block '1' in the main app to block '1' in the child app sub, filling the variable from_main.

[UserObjects<<<{"href": "../../syntax/UserObjects/index.html"}>>>]
  [to_sub]
    type = LayeredAverage<<<{"description": "Computes averages of variables over layers", "href": "../userobjects/LayeredAverage.html"}>>>
    direction<<<{"description": "The direction of the layers."}>>> = x
    num_layers<<<{"description": "The number of layers."}>>> = 10
    variable<<<{"description": "The name of the variable that this object operates on"}>>> = to_sub_var
  []
  [to_sub_elem]
    type = LayeredAverage<<<{"description": "Computes averages of variables over layers", "href": "../userobjects/LayeredAverage.html"}>>>
    direction<<<{"description": "The direction of the layers."}>>> = x
    num_layers<<<{"description": "The number of layers."}>>> = 10
    variable<<<{"description": "The name of the variable that this object operates on"}>>> = to_sub_var_elem
  []
[]
[Transfers<<<{"href": "../../syntax/Transfers/index.html"}>>>]
  [to_sub]
    type = MultiAppGeneralFieldFunctorTransfer<<<{"description": "Transfers functor data at the MultiApp position by evaluating the functor inside its domain of definition and extrapolating with a user-selected behavior outside", "href": "MultiAppGeneralFieldFunctorTransfer.html"}>>>
    to_multi_app<<<{"description": "The name of the MultiApp to transfer the data to"}>>> = sub
    source_functors<<<{"description": "Functors providing the values to transfer to the target variables. A functor is any of the following: a variable, a functor material property, a function, a postprocessor or a number."}>>> = to_sub
    variable<<<{"description": "The auxiliary variable to store the transferred values in."}>>> = from_main
    from_blocks<<<{"description": "Subdomain restriction to transfer from (defaults to all the origin app domain)"}>>> = 1
    to_blocks<<<{"description": "Subdomain restriction to transfer to, (defaults to all the target app domain)"}>>> = 1
    extrapolation_behavior<<<{"description": "How to extrapolate the functors when a target point for the transfer is outside the domain of evaluation"}>>> = 'flat'
    extrapolation_constant<<<{"description": "Constant to use when no source app can provide a valid value for a target location."}>>> = -1
    # Test features non-overlapping meshes
    error_on_miss<<<{"description": "Whether or not to error in the case that a target point is not found in the source domain."}>>> = false
  []
[]

Input Parameters

source_functorsFunctors providing the values to transfer to the target variables. A functor is any of the following: a variable, a functor material property, a function, a postprocessor or a number.
C++ Type:std::vector<MooseFunctorName>
Unit:(no unit assumed)
Controllable:No
Description:Functors providing the values to transfer to the target variables. A functor is any of the following: a variable, a functor material property, a function, a postprocessor or a number.
variableThe auxiliary variable to store the transferred values in.
C++ Type:std::vector<AuxVariableName>
Unit:(no unit assumed)
Controllable:No
Description:The auxiliary variable to store the transferred values in.

Required Parameters

check_multiapp_execute_onTrueWhen false the check between the multiapp and transfer execute on flags is not performed.
Default:True
C++ Type:bool
Controllable:No
Description:When false the check between the multiapp and transfer execute on flags is not performed.
displaced_source_meshFalseWhether or not to use the displaced mesh for the source mesh.
Default:False
C++ Type:bool
Controllable:No
Description:Whether or not to use the displaced mesh for the source mesh.
displaced_target_meshFalseWhether or not to use the displaced mesh for the target mesh.
Default:False
C++ Type:bool
Controllable:No
Description:Whether or not to use the displaced mesh for the target mesh.
execute_onSAME_AS_MULTIAPPThe list of flag(s) indicating when this object should be executed. For a description of each flag, see https://mooseframework.inl.gov/source/interfaces/SetupInterface.html.
Default:SAME_AS_MULTIAPP
C++ Type:ExecFlagEnum
Options:XFEM_MARK, FORWARD, ADJOINT, HOMOGENEOUS_FORWARD, ADJOINT_TIMESTEP_BEGIN, ADJOINT_TIMESTEP_END, NONE, INITIAL, LINEAR, LINEAR_CONVERGENCE, NONLINEAR, NONLINEAR_CONVERGENCE, POSTCHECK, TIMESTEP_END, TIMESTEP_BEGIN, MULTIAPP_FIXED_POINT_END, MULTIAPP_FIXED_POINT_BEGIN, MULTIAPP_FIXED_POINT_CONVERGENCE, FINAL, CUSTOM, SAME_AS_MULTIAPP, POST_ADAPTIVITY
Controllable:No
Description:The list of flag(s) indicating when this object should be executed. For a description of each flag, see https://mooseframework.inl.gov/source/interfaces/SetupInterface.html.
extrapolation_behaviornearest-nodeHow to extrapolate the functors when a target point for the transfer is outside the domain of evaluation
Default:nearest-node
C++ Type:MooseEnum
Options:flat, evaluate_oob, nearest-node, nearest-elem
Controllable:No
Description:How to extrapolate the functors when a target point for the transfer is outside the domain of evaluation
from_multi_appThe name of the MultiApp to receive data from
C++ Type:MultiAppName
Controllable:No
Description:The name of the MultiApp to receive data from
group_subappsFalseWhether to group source locations and values from all subapps when working with a nearest-position or source mesh-division
Default:False
C++ Type:bool
Controllable:No
Description:Whether to group source locations and values from all subapps when working with a nearest-position or source mesh-division
num_nearest_points1Number of nearest source (from) points will be chosen to construct a value for the target point. All points will be selected from the same origin mesh!
Default:1
C++ Type:unsigned int
Controllable:No
Description:Number of nearest source (from) points will be chosen to construct a value for the target point. All points will be selected from the same origin mesh!
post_transfer_extrapolationnonePost treatment to apply to the field after the transfer
Default:none
C++ Type:MooseEnum
Options:none, nearest-valid-target
Controllable:No
Description:Post treatment to apply to the field after the transfer
target_variable_componentsThe target array or vector variable component(s).
C++ Type:std::vector<unsigned int>
Controllable:No
Description:The target array or vector variable component(s).
to_multi_appThe name of the MultiApp to transfer the data to
C++ Type:MultiAppName
Controllable:No
Description:The name of the MultiApp to transfer the data to
value_conflicts_output10Maximum number of conflicts to output if value-conflicts, from equidistant sources to a given transfer target location, search is turned on
Default:10
C++ Type:unsigned int
Controllable:No
Description:Maximum number of conflicts to output if value-conflicts, from equidistant sources to a given transfer target location, search is turned on

Optional Parameters

_called_legacy_paramsTrue
Default:True
C++ Type:bool
Controllable:No
control_tagsAdds user-defined labels for accessing object parameters via control logic.
C++ Type:std::vector<std::string>
Controllable:No
Description:Adds user-defined labels for accessing object parameters via control logic.
enableTrueSet the enabled status of the MooseObject.
Default:True
C++ Type:bool
Controllable:Yes
Description:Set the enabled status of the MooseObject.
skip_coordinate_collapsingTrueWhether to skip coordinate collapsing (translation and rotation are still performed, only XYZ, RZ etc collapsing is skipped) when performing mapping and inverse mapping coordinate transformation operations. This parameter should only be set by users who really know what they're doing.
Default:True
C++ Type:bool
Controllable:No
Description:Whether to skip coordinate collapsing (translation and rotation are still performed, only XYZ, RZ etc collapsing is skipped) when performing mapping and inverse mapping coordinate transformation operations. This parameter should only be set by users who really know what they're doing.
use_displaced_meshFalseWhether or not this object should use the displaced mesh for computation. Note that in the case this is true but no displacements are provided in the Mesh block the undisplaced mesh will still be used.
Default:False
C++ Type:bool
Controllable:No
Description:Whether or not this object should use the displaced mesh for computation. Note that in the case this is true but no displacements are provided in the Mesh block the undisplaced mesh will still be used.

Advanced Parameters

allow_skipped_adjustmentFalseIf set to true, the transfer skips adjustment when from or to postprocessor values are either zero or have different signs. If set to false, an error is thrown when encountering these conditions.
Default:False
C++ Type:bool
Controllable:No
Description:If set to true, the transfer skips adjustment when from or to postprocessor values are either zero or have different signs. If set to false, an error is thrown when encountering these conditions.
from_postprocessors_to_be_preservedThe name of the Postprocessor in the from-app to evaluate an adjusting factor.
C++ Type:std::vector<PostprocessorName>
Unit:(no unit assumed)
Controllable:No
Description:The name of the Postprocessor in the from-app to evaluate an adjusting factor.
to_postprocessors_to_be_preservedThe name of the Postprocessor in the to-app to evaluate an adjusting factor.
C++ Type:std::vector<PostprocessorName>
Unit:(no unit assumed)
Controllable:No
Description:The name of the Postprocessor in the to-app to evaluate an adjusting factor.

Conservative Transfer Parameters

assume_nearest_app_holds_evaluation_locationFalseWhen True, transfers from a child application will work by finding the nearest (using the `position` + mesh centroid) sub-app and query that app for the value to transfer.
Default:False
C++ Type:bool
Controllable:No
Description:When True, transfers from a child application will work by finding the nearest (using the `position` + mesh centroid) sub-app and query that app for the value to transfer.
greedy_searchFalseWhether or not to send a point to all the domains. If true, all the processors will be checked for a given point.The code will be slow if this flag is on but it will give a better solution.
Default:False
C++ Type:bool
Controllable:No
Description:Whether or not to send a point to all the domains. If true, all the processors will be checked for a given point.The code will be slow if this flag is on but it will give a better solution.
search_value_conflictsFalseWhether to look for potential conflicts between two valid and different source values for any target point
Default:False
C++ Type:bool
Controllable:No
Description:Whether to look for potential conflicts between two valid and different source values for any target point
use_bounding_boxesTrueWhen set to false, bounding boxes will not be used to restrict the source of the transfer. Either source applications must be set using the from_mesh_division parameter, or a greedy search must be used.
Default:True
C++ Type:bool
Controllable:No
Description:When set to false, bounding boxes will not be used to restrict the source of the transfer. Either source applications must be set using the from_mesh_division parameter, or a greedy search must be used.
use_nearest_positionName of the the Positions object (in main app) such that transfers to/from a child application will work by finding the nearest position to a target and query only the app / points closer to this position than to any other position for the value to transfer.
C++ Type:PositionsName
Controllable:No
Description:Name of the the Positions object (in main app) such that transfers to/from a child application will work by finding the nearest position to a target and query only the app / points closer to this position than to any other position for the value to transfer.

Search Algorithm Parameters

bbox_factor1Factor to inflate or deflate the source app bounding boxes
Default:1
C++ Type:double
Unit:(no unit assumed)
Range:bbox_factor>0
Controllable:No
Description:Factor to inflate or deflate the source app bounding boxes
fixed_bounding_box_sizeOverride source app bounding box size(s) for searches. App bounding boxes will still be centered on the same coordinates. Only non-zero components passed will override.
C++ Type:std::vector<double>
Unit:(no unit assumed)
Range:fixed_bounding_box_size >= 0
Controllable:No
Description:Override source app bounding box size(s) for searches. App bounding boxes will still be centered on the same coordinates. Only non-zero components passed will override.

Source App Bounding Box Parameters

elemental_boundary_restrictionsidesWhether elemental variable boundary restriction is considered by element side or element nodes
Default:sides
C++ Type:MooseEnum
Options:nodes, sides
Controllable:No
Description:Whether elemental variable boundary restriction is considered by element side or element nodes
from_blocksSubdomain restriction to transfer from (defaults to all the origin app domain)
C++ Type:std::vector<SubdomainName>
Controllable:No
Description:Subdomain restriction to transfer from (defaults to all the origin app domain)
from_boundariesThe boundary we are transferring from (if not specified, whole domain is used).
C++ Type:std::vector<BoundaryName>
Controllable:No
Description:The boundary we are transferring from (if not specified, whole domain is used).
from_mesh_divisionMesh division object on the origin application
C++ Type:MeshDivisionName
Controllable:No
Description:Mesh division object on the origin application
from_mesh_division_usagenoneHow to use the source mesh division in the transfer. See object documentation for description of each option
Default:none
C++ Type:MooseEnum
Options:spatial_restriction, matching_division, matching_subapp_index, none
Controllable:No
Description:How to use the source mesh division in the transfer. See object documentation for description of each option
to_blocksSubdomain restriction to transfer to, (defaults to all the target app domain)
C++ Type:std::vector<SubdomainName>
Controllable:No
Description:Subdomain restriction to transfer to, (defaults to all the target app domain)
to_boundariesThe boundary we are transferring to (if not specified, whole domain is used).
C++ Type:std::vector<BoundaryName>
Controllable:No
Description:The boundary we are transferring to (if not specified, whole domain is used).
to_mesh_divisionMesh division object on the target application
C++ Type:MeshDivisionName
Controllable:No
Description:Mesh division object on the target application
to_mesh_division_usagenoneHow to use the target mesh division in the transfer. See object documentation for description of each option
Default:none
C++ Type:MooseEnum
Options:spatial_restriction, matching_division, matching_subapp_index, none
Controllable:No
Description:How to use the target mesh division in the transfer. See object documentation for description of each option

Transfer Spatial Restriction Parameters

error_on_missTrueWhether or not to error in the case that a target point is not found in the source domain.
Default:True
C++ Type:bool
Controllable:No
Description:Whether or not to error in the case that a target point is not found in the source domain.
extrapolation_constant0Constant to use when no source app can provide a valid value for a target location.
Default:0
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:Constant to use when no source app can provide a valid value for a target location.
from_app_must_contain_pointFalseWether on not the origin mesh must contain the point to evaluate data at. If false, this allows for interpolation between origin app meshes. Origin app bounding boxes are still considered so you may want to increase them with 'fixed_bounding_box_size'
Default:False
C++ Type:bool
Controllable:No
Description:Wether on not the origin mesh must contain the point to evaluate data at. If false, this allows for interpolation between origin app meshes. Origin app bounding boxes are still considered so you may want to increase them with 'fixed_bounding_box_size'

Extrapolation Behavior Parameters

Input Files

(test/tests/transfers/general_field/functor/user_object/boundary/main.i)
(test/tests/transfers/general_field/functor/siblings/main_between_multiapp_functor.i)
(test/tests/transfers/general_field/functor/mesh_division/main_match_subapps_functor.i)
(test/tests/transfers/general_field/functor/user_object/subdomain/main.i)
(test/tests/transfers/general_field/functor/user_object/regular/main.i)
(test/tests/transfers/general_field/functor/nearest_location/between_siblings/main_between_multiapp.i)

(test/tests/transfers/general_field/functor/user_object/subdomain/main.i)

# Base input for testing transfers. It has the following complexities:
# - more than one subapp
# - transfers both from and to the subapps
# - both nodal and elemental variables
# - subapp meshes are not aligned with the main app
# Tests derived from this input may add complexities through command line arguments

[Mesh]
  [gmg]
    type = GeneratedMeshGenerator
    dim = 2
    nx = 5
    ny = 5
  []
  [add_block]
    type = ParsedSubdomainMeshGenerator
    input = gmg
    combinatorial_geometry = 'x < 0.6 & y < 0.5'
    block_id = 1
  []
[]

[AuxVariables]
  [from_sub]
    initial_condition = -1
  []
  [from_sub_elem]
    order = CONSTANT
    family = MONOMIAL
    initial_condition = -1
  []
  [to_sub_var]
    [InitialCondition]
      type = FunctionIC
      function = '1 + 2*x*x + 3*y*y*y'
    []
  []
  [to_sub_var_elem]
    order = CONSTANT
    family = MONOMIAL
    [InitialCondition]
      type = FunctionIC
      function = '2 + 2*x*x + 3*y*y*y'
    []
  []
[]

[UserObjects]
  [to_sub]
    type = LayeredAverage
    direction = x
    num_layers = 10
    variable = to_sub_var
  []
  [to_sub_elem]
    type = LayeredAverage
    direction = x
    num_layers = 10
    variable = to_sub_var_elem
  []
[]

[Executioner]
  type = Transient
  num_steps = 1
[]

[Problem]
  solve = false
[]

[Outputs]
  [out]
    type = Exodus
    hide = 'to_sub_var to_sub_var_elem'
  []
  execute_on = 'TIMESTEP_END'
[]

[MultiApps]
  [sub]
    # 1 on corner, one in the center and one close to a corner
    # Offsets are added to make sure there are no equidistant nodes / transfer indetermination
    positions = '0 0 0 0.41111 0.28111 0 0.7232323 0.12323 0'
    type = TransientMultiApp
    app_type = MooseTestApp
    input_files = sub.i
    execute_on = timestep_end
    output_in_position = true
  []
[]

[Transfers]
  [to_sub]
    type = MultiAppGeneralFieldFunctorTransfer
    to_multi_app = sub
    source_functors = to_sub
    variable = from_main
    from_blocks = 1
    to_blocks = 1
    extrapolation_behavior = 'flat'
    extrapolation_constant = -1
    # Test features non-overlapping meshes
    error_on_miss = false
  []

  [to_sub_elem]
    type = MultiAppGeneralFieldFunctorTransfer
    to_multi_app = sub
    source_functors = to_sub_elem
    variable = from_main_elem
    from_blocks = 1
    to_blocks = 1
    extrapolation_behavior = 'flat'
    extrapolation_constant = -1
    # Test features non-overlapping meshes
    error_on_miss = false
  []

  [from_sub]
    type = MultiAppGeneralFieldFunctorTransfer
    from_multi_app = sub
    source_functors = to_main
    variable = from_sub
    from_blocks = 1
    to_blocks = 1
    extrapolation_behavior = 'flat'
    extrapolation_constant = -1
    # Test features non-overlapping meshes
    error_on_miss = false
  []

  [from_sub_elem]
    type = MultiAppGeneralFieldFunctorTransfer
    from_multi_app = sub
    source_functors = to_main_elem
    variable = from_sub_elem
    from_blocks = 1
    to_blocks = 1
    extrapolation_behavior = 'flat'
    extrapolation_constant = -1
    # Test features non-overlapping meshes
    error_on_miss = false
  []
[]

(test/tests/transfers/general_field/functor/user_object/boundary/main.i)

# Base input for testing transfers. It has the following complexities:
# - more than one subapp
# - transfers both from and to the subapps
# - both nodal and elemental variables
# - subapp meshes are not aligned with the main app
# Tests derived from this input may add complexities through command line arguments

[Mesh]
  [gmg]
    type = GeneratedMeshGenerator
    dim = 3
    nx = 5
    ny = 5
    nz = 5
  []
  [add_block]
    type = ParsedSubdomainMeshGenerator
    input = gmg
    combinatorial_geometry = 'x < 0.5 & y < 0.5'
    block_id = 1
  []
  [add_internal_sideset]
    type = SideSetsBetweenSubdomainsGenerator
    input = add_block
    primary_block = 0
    paired_block = 1
    new_boundary = internal
  []
[]

[AuxVariables]
  [from_sub]
    initial_condition = -1
  []
  [from_sub_elem]
    order = CONSTANT
    family = MONOMIAL
    initial_condition = -1
  []
  [to_sub_var]
    [InitialCondition]
      type = FunctionIC
      function = '1 + 2*x*x + 3*y*y*y'
    []
  []
  [to_sub_var_elem]
    order = CONSTANT
    family = MONOMIAL
    [InitialCondition]
      type = FunctionIC
      function = '2 + 2*x*x + 3*y*y*y'
    []
  []
[]

[UserObjects]
  [to_sub]
    type = LayeredAverage
    direction = x
    num_layers = 10
    variable = to_sub_var
  []
  [to_sub_elem]
    type = LayeredAverage
    direction = x
    num_layers = 10
    variable = to_sub_var_elem
  []
[]

[Executioner]
  type = Transient
  num_steps = 1
[]

[Problem]
  solve = false
  verbose_multiapps = true
[]

[Outputs]
  [out]
    type = Exodus
    hide = 'to_sub_var to_sub_var_elem'
    overwrite = true
  []
[]

[MultiApps]
  [sub]
    # 1 on corner, one in the center and one close to a corner
    # The subapp mesh is a 0.3-sized cube, no overlap
    positions = '0.2222 0 0 0.61111 0.311111 0.31111 0.76666 0.111111 0.81111'
    type = TransientMultiApp
    app_type = MooseTestApp
    input_files = sub.i
    execute_on = timestep_end
    # Facilitates debugging
    output_in_position = true
  []
[]

[Transfers]
  # Boundary restrictions are added in the tests specification
  [to_sub]
    type = MultiAppGeneralFieldFunctorTransfer
    to_multi_app = sub
    source_functors = to_sub
    variable = from_main
    extrapolation_behavior = 'flat'
    extrapolation_constant = -1
    # Test features non-overlapping meshes
    error_on_miss = false
  []

  [to_sub_elem]
    type = MultiAppGeneralFieldFunctorTransfer
    to_multi_app = sub
    source_functors = to_sub_elem
    variable = from_main_elem
    extrapolation_behavior = 'flat'
    extrapolation_constant = -1
    # Test features non-overlapping meshes
    error_on_miss = false
  []

  [from_sub]
    type = MultiAppGeneralFieldFunctorTransfer
    from_multi_app = sub
    source_functors = to_main
    variable = from_sub
    extrapolation_behavior = 'flat'
    extrapolation_constant = -1
    # Test features non-overlapping meshes
    error_on_miss = false
  []

  [from_sub_elem]
    type = MultiAppGeneralFieldFunctorTransfer
    from_multi_app = sub
    source_functors = to_main_elem
    variable = from_sub_elem
    extrapolation_behavior = 'flat'
    extrapolation_constant = -1
    # Test features non-overlapping meshes
    error_on_miss = false
  []
[]

(test/tests/transfers/general_field/functor/siblings/main_between_multiapp_functor.i)

[Problem]
  solve = false
[]

[Mesh]
  type = GeneratedMesh
  dim = 2
[]

[Positions]
  [input_app1]
    type = InputPositions
    # Stacked vertically with a gap so the two sub-app domains do not overlap:
    # ma10 covers [0,1]x[0.1,1.1], ma11 covers [-eps,1-eps]x[1.2,2.2]
    # x-offsets avoid indetermination on vertical Voronoi boundaries
    positions = '0 0.1 0
                 -0.0000001 1.2 0'
  []
  [input_app2]
    type = InputPositions
    # Stacked vertically with a gap so the two sub-app domains do not overlap:
    # ma20 covers [eps,1+eps]x[0.3,1.3], ma21 covers [2eps,1+2eps]x[1.4,2.4]
    # x-offsets avoid indetermination on vertical Voronoi boundaries
    positions = '0.0000001 0.30000000001 0
                 0.0000002 1.40000000001 0'
  []
[]

[MultiApps/ma1]
  type = TransientMultiApp
  input_files = ../../nearest_node/nearest_position/sub_between_diffusion.i
  positions_objects = 'input_app1'
  output_in_position = true
[]

[MultiApps/ma2]
  type = TransientMultiApp
  input_files = ../../nearest_node/nearest_position/sub_between_diffusion.i
  positions_objects = 'input_app2'
  output_in_position = true
[]

[Executioner]
  type = Transient
  num_steps = 1
[]

[Transfers]
  # Nodal to nodal variables
  [app1_to_2_nodal_nodal]
    type = MultiAppGeneralFieldFunctorTransfer
    from_multi_app = ma1
    to_multi_app = ma2
    source_functors = sent_nodal
    variable = received_nodal
    extrapolation_behavior = nearest-node
    use_nearest_position = input_app1
    # slight inflation to avoid floating point issues on borders
    bbox_factor = 1.000001
    search_value_conflicts = true
    group_subapps = true
  []
  [app2_to_1_nodal_nodal]
    type = MultiAppGeneralFieldFunctorTransfer
    from_multi_app = ma2
    to_multi_app = ma1
    source_functors = sent_nodal
    variable = received_nodal
    extrapolation_behavior = nearest-node
    use_nearest_position = input_app2
    bbox_factor = 1.000001
    search_value_conflicts = true
    group_subapps = true
  []

  # Elemental to elemental variables
  [app1_to_2_elem_elem]
    type = MultiAppGeneralFieldFunctorTransfer
    from_multi_app = ma1
    to_multi_app = ma2
    source_functors = sent_elem
    variable = received_elem
    extrapolation_behavior = nearest-elem
    use_nearest_position = input_app1
    bbox_factor = 1.000001
    search_value_conflicts = true
    group_subapps = true
  []
  [app2_to_1_elem_elem]
    type = MultiAppGeneralFieldFunctorTransfer
    from_multi_app = ma2
    to_multi_app = ma1
    source_functors = sent_elem
    variable = received_elem
    extrapolation_behavior = nearest-elem
    use_nearest_position = input_app2
    bbox_factor = 1.000001
    search_value_conflicts = true
    group_subapps = true
  []
[]

(test/tests/transfers/general_field/functor/mesh_division/main_match_subapps_functor.i)

[Mesh]
  type = GeneratedMesh
  dim = 2
  nx = 3
  ny = 3
[]

[MeshDivisions]
  [quadrants]
    type = CartesianGridDivision
    bottom_left = '-.01 -.01 0'
    top_right = '1.02 1.02 0'
    nx = 2
    ny = 2
    nz = 1
  []
[]

[AuxVariables]
  [from_sub]
    initial_condition = -1
  []
  [from_sub_elem]
    order = CONSTANT
    family = MONOMIAL
    initial_condition = -1
  []
  [to_sub]
    [InitialCondition]
      type = FunctionIC
      function = '1 + 2*x*x + 3*y*y*y'
    []
  []
  [to_sub_elem]
    order = CONSTANT
    family = MONOMIAL
    [InitialCondition]
      type = FunctionIC
      function = '2 + 2*x*x + 3*y*y*y'
    []
  []
  [mesh_div]
    order = CONSTANT
    family = MONOMIAL
  []
[]

[AuxKernels]
  [mesh_div]
    type = MeshDivisionAux
    mesh_division = quadrants
    variable = mesh_div
    execute_on = 'initial'
  []
[]

[Executioner]
  type = Steady
[]

[Problem]
  solve = false
[]

[Outputs]
  exodus = true
[]

[MultiApps]
  [sub]
    type = FullSolveMultiApp
    app_type = MooseTestApp
    input_files = sub_corner.i
    output_in_position = true
    # Placed at the four corners so each sub-app sits within one quadrant of 'quadrants'
    positions = '-.04 -.04 0
                 0.94 -.04 0
                 -.04 0.94 0
                 0.94 0.94 0'
  []
[]

[Transfers]
  [to_sub]
    type = MultiAppGeneralFieldFunctorTransfer
    to_multi_app = sub
    source_functors = to_sub
    variable = from_main
    extrapolation_behavior = nearest-node
    from_mesh_division = quadrants
    from_mesh_division_usage = 'matching_subapp_index'
    bbox_factor = 20
    search_value_conflicts = true
  []

  [to_sub_elem]
    type = MultiAppGeneralFieldFunctorTransfer
    to_multi_app = sub
    source_functors = to_sub_elem
    variable = from_main_elem
    extrapolation_behavior = nearest-elem
    from_mesh_division = quadrants
    from_mesh_division_usage = 'matching_subapp_index'
    bbox_factor = 20
    search_value_conflicts = true
  []

  [from_sub]
    type = MultiAppGeneralFieldFunctorTransfer
    from_multi_app = sub
    source_functors = to_main
    variable = from_sub
    extrapolation_behavior = nearest-node
    to_mesh_division = quadrants
    to_mesh_division_usage = 'matching_subapp_index'
    bbox_factor = 20
    search_value_conflicts = true
  []

  [from_sub_elem]
    type = MultiAppGeneralFieldFunctorTransfer
    from_multi_app = sub
    source_functors = to_main_elem
    variable = from_sub_elem
    extrapolation_behavior = nearest-elem
    to_mesh_division = quadrants
    to_mesh_division_usage = 'matching_subapp_index'
    bbox_factor = 20
    search_value_conflicts = true
  []
[]

(test/tests/transfers/general_field/functor/user_object/subdomain/main.i)

# Base input for testing transfers. It has the following complexities:
# - more than one subapp
# - transfers both from and to the subapps
# - both nodal and elemental variables
# - subapp meshes are not aligned with the main app
# Tests derived from this input may add complexities through command line arguments

[Mesh]
  [gmg]
    type = GeneratedMeshGenerator
    dim = 2
    nx = 5
    ny = 5
  []
  [add_block]
    type = ParsedSubdomainMeshGenerator
    input = gmg
    combinatorial_geometry = 'x < 0.6 & y < 0.5'
    block_id = 1
  []
[]

[AuxVariables]
  [from_sub]
    initial_condition = -1
  []
  [from_sub_elem]
    order = CONSTANT
    family = MONOMIAL
    initial_condition = -1
  []
  [to_sub_var]
    [InitialCondition]
      type = FunctionIC
      function = '1 + 2*x*x + 3*y*y*y'
    []
  []
  [to_sub_var_elem]
    order = CONSTANT
    family = MONOMIAL
    [InitialCondition]
      type = FunctionIC
      function = '2 + 2*x*x + 3*y*y*y'
    []
  []
[]

[UserObjects]
  [to_sub]
    type = LayeredAverage
    direction = x
    num_layers = 10
    variable = to_sub_var
  []
  [to_sub_elem]
    type = LayeredAverage
    direction = x
    num_layers = 10
    variable = to_sub_var_elem
  []
[]

[Executioner]
  type = Transient
  num_steps = 1
[]

[Problem]
  solve = false
[]

[Outputs]
  [out]
    type = Exodus
    hide = 'to_sub_var to_sub_var_elem'
  []
  execute_on = 'TIMESTEP_END'
[]

[MultiApps]
  [sub]
    # 1 on corner, one in the center and one close to a corner
    # Offsets are added to make sure there are no equidistant nodes / transfer indetermination
    positions = '0 0 0 0.41111 0.28111 0 0.7232323 0.12323 0'
    type = TransientMultiApp
    app_type = MooseTestApp
    input_files = sub.i
    execute_on = timestep_end
    output_in_position = true
  []
[]

[Transfers]
  [to_sub]
    type = MultiAppGeneralFieldFunctorTransfer
    to_multi_app = sub
    source_functors = to_sub
    variable = from_main
    from_blocks = 1
    to_blocks = 1
    extrapolation_behavior = 'flat'
    extrapolation_constant = -1
    # Test features non-overlapping meshes
    error_on_miss = false
  []

  [to_sub_elem]
    type = MultiAppGeneralFieldFunctorTransfer
    to_multi_app = sub
    source_functors = to_sub_elem
    variable = from_main_elem
    from_blocks = 1
    to_blocks = 1
    extrapolation_behavior = 'flat'
    extrapolation_constant = -1
    # Test features non-overlapping meshes
    error_on_miss = false
  []

  [from_sub]
    type = MultiAppGeneralFieldFunctorTransfer
    from_multi_app = sub
    source_functors = to_main
    variable = from_sub
    from_blocks = 1
    to_blocks = 1
    extrapolation_behavior = 'flat'
    extrapolation_constant = -1
    # Test features non-overlapping meshes
    error_on_miss = false
  []

  [from_sub_elem]
    type = MultiAppGeneralFieldFunctorTransfer
    from_multi_app = sub
    source_functors = to_main_elem
    variable = from_sub_elem
    from_blocks = 1
    to_blocks = 1
    extrapolation_behavior = 'flat'
    extrapolation_constant = -1
    # Test features non-overlapping meshes
    error_on_miss = false
  []
[]

(test/tests/transfers/general_field/functor/user_object/regular/main.i)

# Base input for testing transfers. It has the following complexities:
# - more than one subapp
# - transfers both from and to the subapps
# - both nodal and elemental variables
# Tests derived from this input may add complexities through command line arguments

[Mesh]
  type = GeneratedMesh
  dim = 2
  nx = 10
  ny = 10
[]

[AuxVariables]
  [from_sub]
    initial_condition = -1
  []
  [from_sub_elem]
    order = CONSTANT
    family = MONOMIAL
    initial_condition = -1
  []
  [to_sub_var]
    [InitialCondition]
      type = FunctionIC
      function = '1 + 2*x*x + 3*y*y*y'
    []
  []
  [to_sub_var_elem]
    order = CONSTANT
    family = MONOMIAL
    [InitialCondition]
      type = FunctionIC
      function = '2 + 2*x*x + 3*y*y*y'
    []
  []
[]

[UserObjects]
  [to_sub]
    type = LayeredAverage
    direction = x
    num_layers = 10
    variable = to_sub_var
    execute_on = 'TRANSFER'
  []
  [to_sub_elem]
    type = LayeredAverage
    direction = x
    num_layers = 10
    variable = to_sub_var_elem
    execute_on = 'TRANSFER'
  []
[]

[Executioner]
  type = Steady
[]

[Problem]
  solve = false
[]

[Outputs]
  [out]
    type = Exodus
    hide = 'to_sub_var to_sub_var_elem'
    overwrite = true
  []
[]

[MultiApps]
  [sub]
    # 1 on corner, one in the center and one close to a corner
    positions = '0 0 0 0.4 0.4 0 0.7 0.1 0'
    type = FullSolveMultiApp
    app_type = MooseTestApp
    input_files = sub.i
    output_in_position = true
  []
[]

[Transfers]
  [to_sub]
    type = MultiAppGeneralFieldFunctorTransfer
    to_multi_app = sub
    source_functors = to_sub
    variable = from_main
    extrapolation_behavior = 'flat'
    extrapolation_constant = -1
  []

  [to_sub_elem]
    type = MultiAppGeneralFieldFunctorTransfer
    to_multi_app = sub
    source_functors = to_sub_elem
    variable = from_main_elem
    extrapolation_behavior = 'flat'
    extrapolation_constant = -1
  []

  [from_sub]
    type = MultiAppGeneralFieldFunctorTransfer
    from_multi_app = sub
    source_functors = to_main
    variable = from_sub
    extrapolation_behavior = 'flat'
    extrapolation_constant = -1
    # Test features non-overlapping meshes
    error_on_miss = false
  []

  [from_sub_elem]
    type = MultiAppGeneralFieldFunctorTransfer
    from_multi_app = sub
    source_functors = to_main_elem
    variable = from_sub_elem
    extrapolation_behavior = 'flat'
    extrapolation_constant = -1
    # Test features non-overlapping meshes
    error_on_miss = false
  []
[]

(test/tests/transfers/general_field/functor/nearest_location/between_siblings/main_between_multiapp.i)

# Base input for testing between-multiapp transfers. It has the following complexities:
# - multiapps may not be run with the same number of ranks
# - both nodal and elemental variables
# - transfers between mixes of nodal and elemental variables
# Tests derived from this input may add or remove complexities through command line arguments

[Problem]
  solve = false
[]

[Mesh]
  type = GeneratedMesh
  dim = 2
[]

# This application use at most 3 processes
[MultiApps/ma1]
  type = TransientMultiApp
  input_files = sub_between_diffusion1.i
  max_procs_per_app = 3
[]

# This application will use as many processes as the main app
[MultiApps/ma2]
  type = TransientMultiApp
  input_files = sub_between_diffusion2.i
[]

extrapolation_behavior_node = 'nearest-node'
extrapolation_behavior_elem = 'nearest-elem'

[Transfers]
  # Nodal to nodal variables
  [app1_to_2_nodal_nodal]
    type = MultiAppGeneralFieldFunctorTransfer
    from_multi_app = ma1
    to_multi_app = ma2
    source_functors = sent_nodal
    variable = received_nodal
    extrapolation_behavior = ${extrapolation_behavior_node}
  []
  [app2_to_1_nodal_nodal]
    type = MultiAppGeneralFieldFunctorTransfer
    from_multi_app = ma2
    to_multi_app = ma1
    source_functors = sent_nodal
    variable = received_nodal
    extrapolation_behavior = ${extrapolation_behavior_node}
  []

  # Elemental to elemental variables
  [app1_to_2_elem_elem]
    type = MultiAppGeneralFieldFunctorTransfer
    from_multi_app = ma1
    to_multi_app = ma2
    source_functors = sent_elem
    variable = received_elem
    extrapolation_behavior = ${extrapolation_behavior_elem}
  []
  [app2_to_1_elem_elem]
    type = MultiAppGeneralFieldFunctorTransfer
    from_multi_app = ma2
    to_multi_app = ma1
    source_functors= sent_elem
    variable = received_elem
    extrapolation_behavior = ${extrapolation_behavior_elem}
  []

  # Elemental to nodal variables
  [app1_to_2_elem_nodal]
    type = MultiAppGeneralFieldFunctorTransfer
    from_multi_app = ma1
    to_multi_app = ma2
    source_functors= sent_elem
    variable = received_nodal
    extrapolation_behavior = ${extrapolation_behavior_elem}
  []
  [app2_to_1_elem_nodal]
    type = MultiAppGeneralFieldFunctorTransfer
    from_multi_app = ma2
    to_multi_app = ma1
    source_functors= sent_elem
    variable = received_nodal
    extrapolation_behavior = ${extrapolation_behavior_elem}
  []

  # Nodal to elemental variables
  [app1_to_2_nodal_elem]
    type = MultiAppGeneralFieldFunctorTransfer
    from_multi_app = ma1
    to_multi_app = ma2
    source_functors= sent_nodal
    variable = received_elem
    extrapolation_behavior = ${extrapolation_behavior_node}
  []
  [app2_to_1_nodal_elem]
    type = MultiAppGeneralFieldFunctorTransfer
    from_multi_app = ma2
    to_multi_app = ma1
    source_functors= sent_nodal
    variable = received_elem
    extrapolation_behavior = ${extrapolation_behavior_node}
  []
[]

[Executioner]
  type = Transient
  num_steps = 1
[]

Interpolation behavior
Extrapolation behavior options
Source and target spatial restrictions
Caveats and known numerical issues
Example Input File Syntax
Input Parameters
Input Files