PiecewiseMultilinear

The PiecewiseMultilinear function provides the capability of multi-dimensional piecewise linear interpolation. The data is read from file provided in the data_file argument. Interpolation axes can be a selection of one or multiple of x, y, z, t, the number of interpolation axes is referred to as dimension of the interpolation.

Formatting instructions for the data_file (reproduced from data_file docstring): any empty line and any line beginning with # are ignored, all other lines are assumed to contain relevant information. The file must begin with specification of the grid. This is done through lines containing the keywords: AXIS X; AXIS Y; AXIS Z; or AXIS T. Immediately following the keyword line must be a space-separated line of real numbers which define the grid along the specified axis. These data must be monotonically increasing. After all the axes and their grids have been specified, there must be a line that is DATA. Following that line, function values are given in the correct order (they may be on individual lines, or be space-separated on a number of lines). When the function is evaluated, f(i,j,k,l) corresponds to the i + j*Ni + k*Ni*Nj + l*Ni*Nj*Nk data value. Here i>0 corresponding to the index along the first AXIS, j>0 corresponding to the index along the second AXIS, etc, and Ni = number of grid points along the first AXIS, etc.

PiecewiseMultilinear performs linear interpolation on 1D, 2D, 3D or 4D data. The data_file specifies the axes directions and the function values. If a point lies outside the data range, the appropriate end value is used.

Input Parameters

data_fileFile holding data for use with PiecewiseMultiInterpolation. Format: any empty line and any line beginning with # are ignored, all other lines are assumed to contain relevant information. The file must begin with specification of the grid. This is done through lines containing the keywords: AXIS X; AXIS Y; AXIS Z; or AXIS T. Immediately following the keyword line must be a space-separated line of real numbers which define the grid along the specified axis. These data must be monotonically increasing. After all the axes and their grids have been specified, there must be a line that is DATA. Following that line, function values are given in the correct order (they may be on individual lines, or be space-separated on a number of lines). When the function is evaluated, f[i,j,k,l] corresponds to the i + j*Ni + k*Ni*Nj + l*Ni*Nj*Nk data value. Here i>=0 corresponding to the index along the first AXIS, j>=0 corresponding to the index along the second AXIS, etc, and Ni = number of grid points along the first AXIS, etc.
C++ Type:FileName
Controllable:No
Description:File holding data for use with PiecewiseMultiInterpolation. Format: any empty line and any line beginning with # are ignored, all other lines are assumed to contain relevant information. The file must begin with specification of the grid. This is done through lines containing the keywords: AXIS X; AXIS Y; AXIS Z; or AXIS T. Immediately following the keyword line must be a space-separated line of real numbers which define the grid along the specified axis. These data must be monotonically increasing. After all the axes and their grids have been specified, there must be a line that is DATA. Following that line, function values are given in the correct order (they may be on individual lines, or be space-separated on a number of lines). When the function is evaluated, f[i,j,k,l] corresponds to the i + j*Ni + k*Ni*Nj + l*Ni*Nj*Nk data value. Here i>=0 corresponding to the index along the first AXIS, j>=0 corresponding to the index along the second AXIS, etc, and Ni = number of grid points along the first AXIS, etc.
epsilon1e-12Finite differencing parameter for gradient and time derivative
Default:1e-12
C++ Type:double
Controllable:No
Description:Finite differencing parameter for gradient and time derivative
execute_onLINEARThe list of flag(s) indicating when this object should be executed, the available options include FORWARD, ADJOINT, HOMOGENEOUS_FORWARD, ADJOINT_TIMESTEP_BEGIN, ADJOINT_TIMESTEP_END, NONE, INITIAL, LINEAR, NONLINEAR, POSTCHECK, TIMESTEP_END, TIMESTEP_BEGIN, MULTIAPP_FIXED_POINT_END, MULTIAPP_FIXED_POINT_BEGIN, FINAL, CUSTOM.
Default:LINEAR
C++ Type:ExecFlagEnum
Options:FORWARD, ADJOINT, HOMOGENEOUS_FORWARD, ADJOINT_TIMESTEP_BEGIN, ADJOINT_TIMESTEP_END, NONE, INITIAL, LINEAR, NONLINEAR, POSTCHECK, TIMESTEP_END, TIMESTEP_BEGIN, MULTIAPP_FIXED_POINT_END, MULTIAPP_FIXED_POINT_BEGIN, FINAL, CUSTOM
Controllable:No
Description:The list of flag(s) indicating when this object should be executed, the available options include FORWARD, ADJOINT, HOMOGENEOUS_FORWARD, ADJOINT_TIMESTEP_BEGIN, ADJOINT_TIMESTEP_END, NONE, INITIAL, LINEAR, NONLINEAR, POSTCHECK, TIMESTEP_END, TIMESTEP_BEGIN, MULTIAPP_FIXED_POINT_END, MULTIAPP_FIXED_POINT_BEGIN, FINAL, CUSTOM.

Optional Parameters

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:No
Description:Set the enabled status of the MooseObject.

Advanced Parameters

Input Files

(test/tests/functions/piecewise_multilinear/except5.i)
(modules/phase_field/test/tests/free_energy_material/CoupledValueFunctionFreeEnergy.i)
(modules/porous_flow/examples/reservoir_model/regular_grid.i)
(test/tests/functions/piecewise_multilinear/time.i)
(test/tests/functions/piecewise_multilinear/oneDb.i)
(test/tests/functions/piecewise_multilinear/twoDb.i)
(test/tests/functions/piecewise_multilinear/except3.i)
(test/tests/functions/piecewise_multilinear/twoDa.i)
(test/tests/functions/piecewise_multilinear/except2.i)
(test/tests/functions/piecewise_multilinear/except1.i)
(test/tests/functions/piecewise_multilinear/oneDa.i)
(test/tests/functions/piecewise_multilinear/except4.i)
(test/tests/functions/piecewise_multilinear/fourDa.i)

References

No citations exist within this document.

(test/tests/functions/piecewise_multilinear/except5.i)

# PiecewiseMultilinear function exception test
# No valid AXIS lines in the data_file

[Mesh]
  type = GeneratedMesh
  dim = 1
  xmin = 0
  xmax = 2
  nx = 1
[]

[Variables]
  [./dummy]
  [../]
[]

[Kernels]
  [./dummy_u]
    type = TimeDerivative
    variable = dummy
  [../]
[]


[AuxVariables]
  [./f]
  [../]
[]

[AuxKernels]
  [./f_auxK]
    type = FunctionAux
    variable = f
    function = except5_fcn
  [../]
[]


[Functions]
  [./except5_fcn]
    type = PiecewiseMultilinear
    data_file = except5.txt
  [../]
[]

[Executioner]
  type = Transient
  dt = 1
  end_time = 1
[]

[Outputs]
  execute_on = 'timestep_end'
  hide = dummy
[]

(modules/phase_field/test/tests/free_energy_material/CoupledValueFunctionFreeEnergy.i)

[Mesh]
  type = GeneratedMesh
  dim = 2
  nx = 10
  ny = 10
  nz = 0
  xmin = 0
  xmax = 500
  ymin = 0
  ymax = 500
  zmin = 0
  zmax = 0
  elem_type = QUAD4
[]

[GlobalParams]
  op_num = 4
  var_name_base = gr
[]

[Variables]
  [PolycrystalVariables]
  []
[]

[Functions]
  [grain_growth_energy]
    type = PiecewiseMultilinear
    data_file = grain_growth_energy.data
  []
  [grain_growth_mu0]
    type = PiecewiseMultilinear
    data_file = grain_growth_mu0.data
  []
  [grain_growth_mu1]
    type = PiecewiseMultilinear
    data_file = grain_growth_mu1.data
  []
  [grain_growth_mu2]
    type = PiecewiseMultilinear
    data_file = grain_growth_mu2.data
  []
  [grain_growth_mu3]
    type = PiecewiseMultilinear
    data_file = grain_growth_mu3.data
  []

  [matrix]
    type = ParsedFunction
    expression = '1-x-y-z'
  []
[]

[ICs]
  [gr1]
    type = SmoothCircleIC
    variable = gr1
    x1 = 0
    y1 = 0
    radius = 150
    int_width = 90
    invalue = 1
    outvalue = 0
  []
  [gr2]
    type = SmoothCircleIC
    variable = gr2
    x1 = 500
    y1 = 0
    radius = 120
    int_width = 90
    invalue = 1
    outvalue = 0
  []
  [gr3]
    type = SmoothCircleIC
    variable = gr3
    x1 = 250
    y1 = 500
    radius = 300
    int_width = 90
    invalue = 1
    outvalue = 0
  []
  [gr0]
    type = CoupledValueFunctionIC
    variable = gr0
    v = 'gr1 gr2 gr3'
    function = matrix
  []
[]

[AuxVariables]
  [bnds]
    order = FIRST
    family = LAGRANGE
  []
  [local_energy]
    order = CONSTANT
    family = MONOMIAL
  []
[]

[Kernels]
  [gr0dot]
    type = TimeDerivative
    variable = gr0
  []
  [gr0bulk]
    type = AllenCahn
    variable = gr0
    f_name = F
    coupled_variables = 'gr1 gr2 gr3'
  []
  [gr0int]
    type = ACInterface
    variable = gr0
    kappa_name = kappa_op
  []

  [gr1dot]
    type = TimeDerivative
    variable = gr1
  []
  [gr1bulk]
    type = AllenCahn
    variable = gr1
    f_name = F
    coupled_variables = 'gr0 gr2 gr3'
  []
  [gr1int]
    type = ACInterface
    variable = gr1
    kappa_name = kappa_op
  []

  [gr2dot]
    type = TimeDerivative
    variable = gr2
  []
  [gr2bulk]
    type = AllenCahn
    variable = gr2
    f_name = F
    coupled_variables = 'gr0 gr1 gr3'
  []
  [gr2int]
    type = ACInterface
    variable = gr2
    kappa_name = kappa_op
  []

  [gr3dot]
    type = TimeDerivative
    variable = gr3
  []
  [gr3bulk]
    type = AllenCahn
    variable = gr3
    f_name = F
    coupled_variables = 'gr0 gr1 gr2'
  []
  [gr3int]
    type = ACInterface
    variable = gr3
    kappa_name = kappa_op
  []
[]

[AuxKernels]
  [BndsCalc]
    type = BndsCalcAux
    variable = bnds
  []
  [local_free_energy]
    type = TotalFreeEnergy
    variable = local_energy
    kappa_names = 'kappa_op kappa_op kappa_op kappa_op'
    interfacial_vars = 'gr0 gr1 gr2 gr3'
  []
[]

[Materials]
  [Copper]
    type = GBEvolution
    T = 500 # K
    wGB = 60 # nm
    GBmob0 = 2.5e-6 # m^4/(Js) from Schoenfelder 1997
    Q = 0.23 # Migration energy in eV
    GBenergy = 0.708 # GB energy in J/m^2
  []
  [Tabulated]
    type = CoupledValueFunctionFreeEnergy
    free_energy_function = grain_growth_energy
    chemical_potential_functions = 'grain_growth_mu0 grain_growth_mu1 grain_growth_mu2 '
                                   'grain_growth_mu3'
    v = 'gr0 gr1 gr2 gr3'
  []
[]

[Postprocessors]
  [total_energy]
    type = ElementIntegralVariablePostprocessor
    variable = local_energy
  []
[]

[Preconditioning]
  [SMP]
    type = SMP
    coupled_groups = 'gr0,gr1 gr0,gr2 gr0,gr3'
  []
[]

[Executioner]
  type = Transient
  scheme = bdf2
  solve_type = NEWTON
  l_tol = 1.0e-4
  l_max_its = 30
  nl_max_its = 30
  nl_rel_tol = 1.0e-9
  start_time = 0.0
  num_steps = 3
  dt = 100.0
[]

[Outputs]
  exodus = true
  print_linear_residuals = false
  perf_graph = true
[]

(modules/porous_flow/examples/reservoir_model/regular_grid.i)

# SPE 10 comparative problem - model 1
# Data and description from https://www.spe.org/web/csp/datasets/set01.htm
# Simple input file that just establishes gravity equilibrium in the model
#
# Heterogeneous permeability is included by reading data from an external file
# using the PiecewiseMultilinear function, and saving that data to an elemental
# AuxVariable that is then used in PorousFlowPermeabilityConstFromVar

[Mesh]
  type = GeneratedMesh
  dim = 2
  nx = 100
  ny = 20
  xmax = 762
  ymax = 15.24
[]

[GlobalParams]
  PorousFlowDictator = dictator
  gravity = '0 -9.81 0'
  temperature_unit = Celsius
[]

[Variables]
  [porepressure]
    initial_condition = 20e6
  []
[]

[Functions]
  [perm_md_fcn]
    type = PiecewiseMultilinear
    data_file = spe10_case1.data
  []
[]

[BCs]
  [top]
    type = DirichletBC
    variable = porepressure
    value = 20e6
    boundary = top
  []
[]

[AuxVariables]
  [temperature]
    initial_condition = 50
  []
  [xnacl]
    initial_condition = 0.1
  []
  [porosity]
    family = MONOMIAL
    order = CONSTANT
    initial_condition = 0.2
  []
  [perm_md]
    family = MONOMIAL
    order = CONSTANT
  []
  [perm]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[Kernels]
  [mass0]
    type = PorousFlowMassTimeDerivative
    variable = porepressure
  []
  [flux0]
    type = PorousFlowFullySaturatedDarcyFlow
    variable = porepressure
  []
[]

[AuxKernels]
  [perm_md]
    type = FunctionAux
    function = perm_md_fcn
    variable = perm_md
    execute_on = initial
  []
  [perm]
    type = ParsedAux
    variable = perm
    coupled_variables = perm_md
    expression = '9.869233e-16*perm_md'
    execute_on = initial
  []
[]

[UserObjects]
  [dictator]
    type = PorousFlowDictator
    porous_flow_vars = porepressure
    number_fluid_phases = 1
    number_fluid_components = 1
  []
[]

[FluidProperties]
  [water]
    type = Water97FluidProperties
  []
  [watertab]
    type = TabulatedBicubicFluidProperties
    fp = water
    save_file = false
  []
[]

[Materials]
  [temperature]
    type = PorousFlowTemperature
    temperature = temperature
  []
  [ps]
    type = PorousFlow1PhaseFullySaturated
    porepressure = porepressure
  []
  [massfrac]
    type = PorousFlowMassFraction
  []
  [brine]
    type = PorousFlowBrine
    compute_enthalpy = false
    compute_internal_energy = false
    xnacl = xnacl
    phase = 0
    water_fp = watertab
  []
  [porosity]
    type = PorousFlowPorosityConst
    porosity = porosity
  []
  [permeability]
    type = PorousFlowPermeabilityConstFromVar
    perm_xx = perm
    perm_yy = perm
    perm_zz = perm
  []
[]

[Preconditioning]
  [smp]
    type = SMP
    full = true
  []
[]

[Executioner]
  type = Transient
  solve_type = Newton
  end_time = 1e5
  nl_abs_tol = 1e-12
  nl_rel_tol = 1e-06
  steady_state_detection = true
  steady_state_tolerance = 1e-12
  [TimeStepper]
    type = IterationAdaptiveDT
    dt = 1e2
  []
[]

[Outputs]
  execute_on = 'initial timestep_end'
  exodus = true
  perf_graph = true
[]

(test/tests/functions/piecewise_multilinear/time.i)

# PiecewiseMultilinear function tests for time-dependent data
# See [Functions] block for a description of the tests

[Mesh]
  type = GeneratedMesh
  dim = 3
  xmin = 0
  xmax = 1
  nx = 1
  ymin = 0
  ymax = 1
  ny = 1
  zmin = 0
  zmax = 1
  nz = 1
[]

[Variables]
  [./dummy]
  [../]
[]

[Kernels]
  [./dummy_u]
    type = TimeDerivative
    variable = dummy
  [../]
[]


[AuxVariables]
  [./time1_var]
  [../]
[]

[AuxKernels]
  [./time1_AuxK]
    type = FunctionAux
    variable = time1_var
    function = time1_fcn
  [../]
[]

[Functions]
# This increases linearly: f = t
  [./time1_fcn]
    type = PiecewiseMultilinear
    data_file = time1.txt
  [../]
  [./time1_answer]
    type = ParsedFunction
    expression = t
  [../]
[]

[Postprocessors]
  [./time1_pp]
    type = NodalL2Error
    function = time1_answer
    variable = time1_var
  [../]
[]


[Executioner]
  type = Transient
  dt = 0.1
  end_time = 1
[]

[Outputs]
  execute_on = 'timestep_end'
  file_base = time
  hide = dummy
  csv = true
[]

(test/tests/functions/piecewise_multilinear/oneDb.i)

# PiecewiseMultilinear function tests in 1D
# See [Functions] block for a description of the tests
# The functions are compared with ParsedFunctions using postprocessors

[Mesh]
  type = GeneratedMesh
  dim = 1
  xmin = 0
  xmax = 2
  nx = 10
[]

[Variables]
  [./dummy]
  [../]
[]

[Kernels]
  [./dummy_u]
    type = TimeDerivative
    variable = dummy
  [../]
[]


[AuxVariables]
  [./linear1_var]
  [../]
  [./linear2_var]
  [../]
[]

[AuxKernels]
  [./linear1_AuxK]
    type = FunctionAux
    variable = linear1_var
    function = linear1_fcn
  [../]
  [./linear2_AuxK]
    type = FunctionAux
    variable = linear2_var
    function = linear2_fcn
  [../]
[]


[Functions]
# This is just f = x
  [./linear1_fcn]
    type = PiecewiseMultilinear
    data_file = linear1.txt
  [../]
  [./linear1_answer]
    type = ParsedFunction
    expression = x
  [../]

# This is a hat function
  [./linear2_fcn]
    type = PiecewiseMultilinear
    data_file = linear2.txt
  [../]
  [./linear2_answer]
    type = ParsedFunction
    expression = min(x,1)+min(2-x,1)-1
  [../]

[]

[Postprocessors]
  [./linear1_pp]
    type = NodalL2Error
    function = linear1_answer
    variable = linear1_var
  [../]
  [./linear2_pp]
    type = NodalL2Error
    function = linear2_answer
    variable = linear2_var
  [../]
[]

[Executioner]
  type = Transient
  dt = 1
  end_time = 1
[]

[Outputs]
  execute_on = 'timestep_end'
  file_base = oneDb
  hide = dummy
  csv = true
[]

(test/tests/functions/piecewise_multilinear/twoDb.i)

# PiecewiseMultilinear function tests in 2D
# The spatial grid is 1<=x<=5 and 1<=y<=5
# At t<=1 a disk of radius 0.5 sits at (x,y)=(1.45,1.45): it has f=1.  Elsewhere f=0
# At t>=0 a disk of radius 0.5 sits at (x,y)=(4,55,4,55): it has f=1.  Elsewhere f=0
# The disks' centers were chosen specially so that the disk partially sits outside the grid
# which illustrates the extrapolation process used by GriddedData and PiecewiseMultilinear
[Mesh]
  type = GeneratedMesh
  dim = 2
  xmin = 0
  xmax = 6
  nx = 60
  ymin = 0
  ymax = 6
  ny = 60
[]

[Variables]
  [./dummy]
  [../]
[]

[Kernels]
  [./dummy_u]
    type = TimeDerivative
    variable = dummy
  [../]
[]


[AuxVariables]
  [./moving_disk_var]
  [../]
[]

[AuxKernels]
  [./moving_disk_AuxK]
    type = FunctionAux
    variable = moving_disk_var
    function = moving_disk_fcn
  [../]
[]


[Functions]
  [./moving_disk_fcn]
    type = PiecewiseMultilinear
    data_file = twoD2.txt
  [../]
[]


[Executioner]
  type = Transient
  dt = 0.5
  end_time = 10
[]

[Outputs]
  execute_on = 'timestep_end'
  file_base = twoDb
  hide = dummy
  exodus = true
  csv = true
[]

(test/tests/functions/piecewise_multilinear/except3.i)

# PiecewiseMultilinear function exception test
# Incorrect number of data points

[Mesh]
  type = GeneratedMesh
  dim = 1
  xmin = 0
  xmax = 2
  nx = 1
[]

[Variables]
  [./dummy]
  [../]
[]

[Kernels]
  [./dummy_u]
    type = TimeDerivative
    variable = dummy
  [../]
[]


[AuxVariables]
  [./f]
  [../]
[]

[AuxKernels]
  [./f_auxK]
    type = FunctionAux
    variable = f
    function = except3_fcn
  [../]
[]


[Functions]
  [./except3_fcn]
    type = PiecewiseMultilinear
    data_file = except3.txt
  [../]
[]


[Executioner]
  type = Transient
  dt = 1
  end_time = 1
[]

[Outputs]
  execute_on = 'timestep_end'
  hide = dummy
[]

(test/tests/functions/piecewise_multilinear/twoDa.i)

# PiecewiseMultilinear function tests in 2D
# See [Functions] block for a description of the tests
# The functions are compared with ParsedFunctions using postprocessors

[Mesh]
  type = GeneratedMesh
  dim = 2
  xmin = 0
  xmax = 1
  nx = 6
  ymin = 0
  ymax = 1
  ny = 6
[]

[Variables]
  [./dummy]
  [../]
[]

[Kernels]
  [./dummy_u]
    type = TimeDerivative
    variable = dummy
  [../]
[]


[AuxVariables]
  [./bilinear1_var]
  [../]
[]

[AuxKernels]
  [./bilinear1_AuxK]
    type = FunctionAux
    variable = bilinear1_var
    function = bilinear1_fcn
  [../]
[]


[Functions]
# This is just f = 1 + 2x + 3y
  [./bilinear1_fcn]
    type = PiecewiseMultilinear
    data_file = twoD1.txt
  [../]
  [./bilinear1_answer]
    type = ParsedFunction
    expression = 1+2*x+3*y
  [../]
[]

[Postprocessors]
  [./bilinear1_pp]
    type = NodalL2Error
    function = bilinear1_answer
    variable = bilinear1_var
  [../]
[]

[Executioner]
  type = Transient
  dt = 1
  end_time = 1
[]

[Outputs]
  execute_on = 'timestep_end'
  file_base = twoDa
  hide = dummy
  csv = true
[]

(test/tests/functions/piecewise_multilinear/except2.i)

# PiecewiseMultilinear function exception test
# Grid is not monotonic

[Mesh]
  type = GeneratedMesh
  dim = 1
  xmin = 0
  xmax = 2
  nx = 1
[]

[Variables]
  [./dummy]
  [../]
[]

[Kernels]
  [./dummy_u]
    type = TimeDerivative
    variable = dummy
  [../]
[]


[AuxVariables]
  [./f]
  [../]
[]

[AuxKernels]
  [./f_auxK]
    type = FunctionAux
    variable = f
    function = except1_fcn
  [../]
[]


[Functions]
  [./except1_fcn]
    type = PiecewiseMultilinear
    data_file = except2.txt
  [../]
[]

[Executioner]
  type = Transient
  dt = 1
  end_time = 1
[]

[Outputs]
  execute_on = 'timestep_end'
  hide = dummy
[]

(test/tests/functions/piecewise_multilinear/except1.i)

# PiecewiseMultilinear function exception test
# Data file does not exist

[Mesh]
  type = GeneratedMesh
  dim = 1
  xmin = 0
  xmax = 2
  nx = 1
[]

[Variables]
  [./dummy]
  [../]
[]

[Kernels]
  [./dummy_u]
    type = TimeDerivative
    variable = dummy
  [../]
[]


[AuxVariables]
  [./f]
  [../]
[]

[AuxKernels]
  [./f_auxK]
    type = FunctionAux
    variable = f
    function = except1_fcn
  [../]
[]


[Functions]
  [./except1_fcn]
    type = PiecewiseMultilinear
    data_file = except1.txt
  [../]
[]


[Executioner]
  type = Transient
  dt = 1
  end_time = 1
[]

[Outputs]
  execute_on = 'timestep_end'
  file_base = except1
  hide = dummy
  csv = true
[]

(test/tests/functions/piecewise_multilinear/oneDa.i)

# PiecewiseMultilinear function tests in 1D
# See [Functions] block for a description of the tests
# All tests yield variable = 1 everywhere, so they are compared using postprocessors

[Mesh]
  type = GeneratedMesh
  dim = 1
  xmin = 0
  xmax = 2
  nx = 10
[]

[Variables]
  [./dummy]
  [../]
[]

[Kernels]
  [./dummy_u]
    type = TimeDerivative
    variable = dummy
  [../]
[]


[AuxVariables]
  [./end1_var]
  [../]

  [./end2_var]
  [../]

  [./end3_var]
  [../]

  [./end4_var]
  [../]

  [./one_pt1_var]
  [../]

  [./one_pt2_var]
  [../]

  [./one_pt3_var]
  [../]

  [./other_axis1_var]
  [../]

  [./other_axis2_var]
  [../]

  [./other_axis3_var]
  [../]
[]

[AuxKernels]
  [./end1_auxK]
    type = FunctionAux
    variable = end1_var
    function = end1_fcn
  [../]

  [./end2_auxK]
    type = FunctionAux
    variable = end2_var
    function = end2_fcn
  [../]

  [./end3_auxK]
    type = FunctionAux
    variable = end3_var
    function = end3_fcn
  [../]

  [./end4_auxK]
    type = FunctionAux
    variable = end4_var
    function = end4_fcn
  [../]

  [./one_pt1_auxK]
    type = FunctionAux
    variable = one_pt1_var
    function = one_pt1_fcn
  [../]

  [./one_pt2_auxK]
    type = FunctionAux
    variable = one_pt2_var
    function = one_pt2_fcn
  [../]

  [./one_pt3_auxK]
    type = FunctionAux
    variable = one_pt3_var
    function = one_pt3_fcn
  [../]

  [./other_axis1_auxK]
    type = FunctionAux
    variable = other_axis1_var
    function = other_axis1_fcn
  [../]

  [./other_axis2_auxK]
    type = FunctionAux
    variable = other_axis2_var
    function = other_axis2_fcn
  [../]

  [./other_axis3_auxK]
    type = FunctionAux
    variable = other_axis3_var
    function = other_axis3_fcn
  [../]
[]


[Functions]
# The result (which is unity) that all the functions should yield
  [./answer_fcn]
    type = ConstantFunction
    value = 1
  [../]

# Function that is 1 for all x>=0, due to data only being defined on x<0
  [./end1_fcn]
    type = PiecewiseMultilinear
    data_file = end1.txt
  [../]

# Function that is 1 for all x>=0, due to data only being defined on x<=0
  [./end2_fcn]
    type = PiecewiseMultilinear
    data_file = end2.txt
  [../]

# Function that is 1 for all x<=2, due to data only being defined on x>2
  [./end3_fcn]
    type = PiecewiseMultilinear
    data_file = end3.txt
  [../]

# Function that is 1 for all x<=2, due to data only being defined on x>=2
  [./end4_fcn]
    type = PiecewiseMultilinear
    data_file = end4.txt
  [../]

# Function that is 1 for all x, due to only one point being defined on X at x=2
  [./one_pt1_fcn]
    type = PiecewiseMultilinear
    data_file = one_pt1.txt
  [../]

# Function that is 1 for all x, due to only one point being defined on X at x=1
  [./one_pt2_fcn]
    type = PiecewiseMultilinear
    data_file = one_pt2.txt
  [../]

# Function that is 1 for all x, due to only one point being defined on X at x=-1
  [./one_pt3_fcn]
    type = PiecewiseMultilinear
    data_file = one_pt3.txt
  [../]

# Function that is 1 for all x, and data is defined on Y axis only
  [./other_axis1_fcn]
    type = PiecewiseMultilinear
    data_file = other_axis1.txt
  [../]

# Function that is 1 for all x, and data is defined on T axis only for t>=1
  [./other_axis2_fcn]
    type = PiecewiseMultilinear
    data_file = other_axis2.txt
  [../]

# Function that is 1 for all x, and data that is unity and defined on T axis for -1<=t<=1
  [./other_axis3_fcn]
    type = PiecewiseMultilinear
    data_file = other_axis3.txt
  [../]
[]

[Postprocessors]
  [./end1_pp]
    type = NodalL2Error
    function = answer_fcn
    variable = end1_var
  [../]
  [./end2_pp]
    type = NodalL2Error
    function = answer_fcn
    variable = end2_var
  [../]
  [./end3_pp]
    type = NodalL2Error
    function = answer_fcn
    variable = end3_var
  [../]
  [./one_pt1_pp]
    type = NodalL2Error
    function = answer_fcn
    variable = one_pt1_var
  [../]
  [./one_pt2_pp]
    type = NodalL2Error
    function = answer_fcn
    variable = one_pt2_var
  [../]
  [./one_pt3_pp]
    type = NodalL2Error
    function = answer_fcn
    variable = one_pt3_var
  [../]
  [./other_axis1_pp]
    type = NodalL2Error
    function = answer_fcn
    variable = other_axis1_var
  [../]
  [./other_axis2_pp]
    type = NodalL2Error
    function = answer_fcn
    variable = other_axis2_var
  [../]
  [./other_axis3_pp]
    type = NodalL2Error
    function = answer_fcn
    variable = other_axis3_var
  [../]
[]

[Executioner]
  type = Transient
  dt = 0.5
  end_time = 1
[]

[Outputs]
  execute_on = 'timestep_end'
  file_base = oneDa
  hide = dummy
  exodus = false
  csv = true
[]

(test/tests/functions/piecewise_multilinear/except4.i)

# PiecewiseMultilinear function exception test
# AXIS X encountered more than once

[Mesh]
  type = GeneratedMesh
  dim = 1
  xmin = 0
  xmax = 2
  nx = 1
[]

[Variables]
  [./dummy]
  [../]
[]

[Kernels]
  [./dummy_u]
    type = TimeDerivative
    variable = dummy
  [../]
[]


[AuxVariables]
  [./f]
  [../]
[]

[AuxKernels]
  [./f_auxK]
    type = FunctionAux
    variable = f
    function = except4_fcn
  [../]
[]


[Functions]
  [./except4_fcn]
    type = PiecewiseMultilinear
    data_file = except4.txt
  [../]
[]

[Executioner]
  type = Transient
  dt = 1
  end_time = 1
[]

[Outputs]
  execute_on = 'timestep_end'
  hide = dummy
[]

(test/tests/functions/piecewise_multilinear/fourDa.i)

# PiecewiseMultilinear function test in 3D with function depending on time
#
# This test uses a function on the unit cube.
# For t<=3 the function is unity at (x,y,z)=(0,0,0) and zero elsewhere
# For t>=7 the function is unity at (x,y,z)=(1,1,1) and zero elsewhere

[Mesh]
  type = GeneratedMesh
  dim = 3
  xmin = 0
  xmax = 1
  nx = 2
  ymin = 0
  ymax = 1
  ny = 2
  zmin = 0
  zmax = 1
  nz = 2
[]

[Variables]
  [./dummy]
  [../]
[]

[Kernels]
  [./dummy_kernel]
    type = TimeDerivative
    variable = dummy
  [../]
[]

[AuxVariables]
  [./f]
  [../]
[]

[AuxKernels]
  [./f_AuxK]
    type = FunctionAux
    function = fourDa
    variable = f
  [../]
[]

[Functions]
  [./fourDa]
    type = PiecewiseMultilinear
    data_file = fourDa.txt
  [../]
[]


[Executioner]
  type = Transient
  dt = 1
  end_time = 10
[]

[Outputs]
  file_base = fourDa
  exodus = true
  hide = dummy
[]

Input Parameters
Input Files
References