PorousFlowElementNormal

This AuxKernel calculates the element normal, and returns the x, y, or z component. This is mostly designed for 2D elements living in 3D space, however, the 1D and 3D cases are handled as special cases using the "1D_perp" and "3D_default" inputs.

For 2D elements, the normal is calculated by:

Construct the vector $var element = document.getElementById("moose-equation-738449cc-136e-449e-af70-0bbea134a1e2");katex.render("(n_{2} - n_{1})\\times (n_{0} - n_{1})", element, {displayMode:false,throwOnError:false,macros:{"\\eqc":"\\,,","\\eqp":"\\,.","\\pd":"\\frac{\\partial #1}{\\partial #2}","\\pr":"\\left(#1\\right)","\\ddt":"\\frac{d #1}{d t}"}});$ , where $var element = document.getElementById("moose-equation-48d0e5a1-d2da-4e40-98be-df5316f6c584");katex.render("\\times", element, {displayMode:false,throwOnError:false,macros:{"\\eqc":"\\,,","\\eqp":"\\,.","\\pd":"\\frac{\\partial #1}{\\partial #2}","\\pr":"\\left(#1\\right)","\\ddt":"\\frac{d #1}{d t}"}});$ is the cross-product, and $var element = document.getElementById("moose-equation-ad31e29f-6da0-4ad4-a6e6-31f305445c6b");katex.render("n_{i}", element, {displayMode:false,throwOnError:false,macros:{"\\eqc":"\\,,","\\eqp":"\\,.","\\pd":"\\frac{\\partial #1}{\\partial #2}","\\pr":"\\left(#1\\right)","\\ddt":"\\frac{d #1}{d t}"}});$ is the position of the $var element = document.getElementById("moose-equation-964961c9-143e-4ded-a140-2e7e9dd4b719");katex.render("i^{\\mathrm{th}}", element, {displayMode:false,throwOnError:false,macros:{"\\eqc":"\\,,","\\eqp":"\\,.","\\pd":"\\frac{\\partial #1}{\\partial #2}","\\pr":"\\left(#1\\right)","\\ddt":"\\frac{d #1}{d t}"}});$ node.
Construct the vector $var element = document.getElementById("moose-equation-ec451382-aceb-41d7-9283-ebde5092a5f0");katex.render("(n_{3} - n_{2})\\times (n_{1} - n_{2})", element, {displayMode:false,throwOnError:false,macros:{"\\eqc":"\\,,","\\eqp":"\\,.","\\pd":"\\frac{\\partial #1}{\\partial #2}","\\pr":"\\left(#1\\right)","\\ddt":"\\frac{d #1}{d t}"}});$
$var element = document.getElementById("moose-equation-f346a3b6-cca9-4d13-bb5b-b77de8b0216a");katex.render("\\ldots", element, {displayMode:false,throwOnError:false,macros:{"\\eqc":"\\,,","\\eqp":"\\,.","\\pd":"\\frac{\\partial #1}{\\partial #2}","\\pr":"\\left(#1\\right)","\\ddt":"\\frac{d #1}{d t}"}});$
Construct the vector $var element = document.getElementById("moose-equation-cba1bba5-ca36-4d03-99d0-5e205c5436cc");katex.render("(n_{N-1} - n_{N-2})\\times (n_{N-3} - n_{N-2})", element, {displayMode:false,throwOnError:false,macros:{"\\eqc":"\\,,","\\eqp":"\\,.","\\pd":"\\frac{\\partial #1}{\\partial #2}","\\pr":"\\left(#1\\right)","\\ddt":"\\frac{d #1}{d t}"}});$ , where $var element = document.getElementById("moose-equation-973ea8ea-16ab-427b-81dd-b015c9ccce95");katex.render("N", element, {displayMode:false,throwOnError:false,macros:{"\\eqc":"\\,,","\\eqp":"\\,.","\\pd":"\\frac{\\partial #1}{\\partial #2}","\\pr":"\\left(#1\\right)","\\ddt":"\\frac{d #1}{d t}"}});$ is the number of nodes in the element. Hence, for triangular linear Lagrange elements ( $var element = document.getElementById("moose-equation-e84fbfb8-4b79-4f45-a34d-13e91f7e2843");katex.render("N=3", element, {displayMode:false,throwOnError:false,macros:{"\\eqc":"\\,,","\\eqp":"\\,.","\\pd":"\\frac{\\partial #1}{\\partial #2}","\\pr":"\\left(#1\\right)","\\ddt":"\\frac{d #1}{d t}"}});$ ) only 1 vector is constructed, for quadrilateral linear Lagrange elements ( $var element = document.getElementById("moose-equation-63631eb4-0c81-4616-b407-e04cdc45e957");katex.render("N=4", element, {displayMode:false,throwOnError:false,macros:{"\\eqc":"\\,,","\\eqp":"\\,.","\\pd":"\\frac{\\partial #1}{\\partial #2}","\\pr":"\\left(#1\\right)","\\ddt":"\\frac{d #1}{d t}"}});$ ) 2 vectors are constructed
Sum these vectors, normalise, and return the result

For 1D elements, the normal is calculated by:

Construct the vector $var element = document.getElementById("moose-equation-ad7bc750-4bcd-4c6a-9699-1c60777aaf1b");katex.render("v\\times (n_{1} - n_{0})", element, {displayMode:false,throwOnError:false,macros:{"\\eqc":"\\,,","\\eqp":"\\,.","\\pd":"\\frac{\\partial #1}{\\partial #2}","\\pr":"\\left(#1\\right)","\\ddt":"\\frac{d #1}{d t}"}});$ , where $var element = document.getElementById("moose-equation-c0022263-9647-449a-8fdb-04cdf60ea652");katex.render("v", element, {displayMode:false,throwOnError:false,macros:{"\\eqc":"\\,,","\\eqp":"\\,.","\\pd":"\\frac{\\partial #1}{\\partial #2}","\\pr":"\\left(#1\\right)","\\ddt":"\\frac{d #1}{d t}"}});$ is the "1D_perp" vector supplied by the user
Construct the vector $var element = document.getElementById("moose-equation-fd0ea3ca-a43c-46aa-91b8-531208c369b6");katex.render("v\\times (n_{2} - n_{1})", element, {displayMode:false,throwOnError:false,macros:{"\\eqc":"\\,,","\\eqp":"\\,.","\\pd":"\\frac{\\partial #1}{\\partial #2}","\\pr":"\\left(#1\\right)","\\ddt":"\\frac{d #1}{d t}"}});$
$var element = document.getElementById("moose-equation-e36bfc81-e515-466c-a2a0-7b623dfc06fa");katex.render("\\ldots", element, {displayMode:false,throwOnError:false,macros:{"\\eqc":"\\,,","\\eqp":"\\,.","\\pd":"\\frac{\\partial #1}{\\partial #2}","\\pr":"\\left(#1\\right)","\\ddt":"\\frac{d #1}{d t}"}});$
Construct the vector $var element = document.getElementById("moose-equation-1cd265b9-f652-4191-bfe2-33615c76ff64");katex.render("v\\times (n_{N-1} - n_{N-2})", element, {displayMode:false,throwOnError:false,macros:{"\\eqc":"\\,,","\\eqp":"\\,.","\\pd":"\\frac{\\partial #1}{\\partial #2}","\\pr":"\\left(#1\\right)","\\ddt":"\\frac{d #1}{d t}"}});$ , where $var element = document.getElementById("moose-equation-9e96e01d-7c8c-4a90-9124-d02c27effddb");katex.render("N", element, {displayMode:false,throwOnError:false,macros:{"\\eqc":"\\,,","\\eqp":"\\,.","\\pd":"\\frac{\\partial #1}{\\partial #2}","\\pr":"\\left(#1\\right)","\\ddt":"\\frac{d #1}{d t}"}});$ is the number of nodes in the element. Hence, for bar linear Lagrange elements ( $var element = document.getElementById("moose-equation-07b9321d-b8c5-47e3-8c81-ec0b886dcd2b");katex.render("N=2", element, {displayMode:false,throwOnError:false,macros:{"\\eqc":"\\,,","\\eqp":"\\,.","\\pd":"\\frac{\\partial #1}{\\partial #2}","\\pr":"\\left(#1\\right)","\\ddt":"\\frac{d #1}{d t}"}});$ ) only 1 vector is constructed
Sum these vectors, normalise, and return the result

For 3D elements, the "3D_default" is returned.

note

Only elemental (Monomial) AuxVariables can be used with this AuxKernel

Input Parameters

componentThe component to compute
C++ Type:MooseEnum
Options:x, y, z
Controllable:No
Description:The component to compute
variableThe name of the variable that this object applies to
C++ Type:AuxVariableName
Controllable:No
Description:The name of the variable that this object applies to

Required Parameters

1D_perp0 0 1The normal for all 1D elements will be perpendicular to this vector
Default:0 0 1
C++ Type:libMesh::VectorValue<double>
Controllable:No
Description:The normal for all 1D elements will be perpendicular to this vector
3D_default0 0 1The value that will be produced for 3D elements, since such elements do not have a 'normal direction'
Default:0 0 1
C++ Type:libMesh::VectorValue<double>
Controllable:No
Description:The value that will be produced for 3D elements, since such elements do not have a 'normal direction'
blockThe list of blocks (ids or names) that this object will be applied
C++ Type:std::vector<SubdomainName>
Controllable:No
Description:The list of blocks (ids or names) that this object will be applied
boundaryThe list of boundaries (ids or names) from the mesh where this boundary condition applies
C++ Type:std::vector<BoundaryName>
Controllable:No
Description:The list of boundaries (ids or names) from the mesh where this boundary condition applies
check_boundary_restrictedTrueWhether to check for multiple element sides on the boundary in the case of a boundary restricted, element aux variable. Setting this to false will allow contribution to a single element's elemental value(s) from multiple boundary sides on the same element (example: when the restricted boundary exists on two or more sides of an element, such as at a corner of a mesh
Default:True
C++ Type:bool
Controllable:No
Description:Whether to check for multiple element sides on the boundary in the case of a boundary restricted, element aux variable. Setting this to false will allow contribution to a single element's elemental value(s) from multiple boundary sides on the same element (example: when the restricted boundary exists on two or more sides of an element, such as at a corner of a mesh
execute_onLINEAR TIMESTEP_ENDThe list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE, ALWAYS.
Default:LINEAR TIMESTEP_END
C++ Type:ExecFlagEnum
Options:NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE, ALWAYS
Controllable:No
Description:The list of flag(s) indicating when this object should be executed, the available options include NONE, INITIAL, LINEAR, NONLINEAR, TIMESTEP_END, TIMESTEP_BEGIN, FINAL, CUSTOM, PRE_DISPLACE, ALWAYS.
prop_getter_suffixAn optional suffix parameter that can be appended to any attempt to retrieve/get material properties. The suffix will be prepended with a '_' character.
C++ Type:MaterialPropertyName
Controllable:No
Description:An optional suffix parameter that can be appended to any attempt to retrieve/get material properties. The suffix will be prepended with a '_' character.

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:Yes
Description:Set the enabled status of the MooseObject.
seed0The seed for the master random number generator
Default:0
C++ Type:unsigned int
Controllable:No
Description:The seed for the master random number generator
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

Input Files

(modules/porous_flow/test/tests/aux_kernels/element_normal_except1.i)
(modules/porous_flow/test/tests/aux_kernels/element_normal_1D_2D.i)
(modules/porous_flow/examples/multiapp_fracture_flow/3dFracture/fracture_only_aperture_changing.i)
(modules/porous_flow/test/tests/aux_kernels/element_normal_except2.i)
(modules/porous_flow/test/tests/aux_kernels/element_normal_2D_3D.i)
(modules/porous_flow/test/tests/aux_kernels/element_normal_except3.i)

(modules/porous_flow/test/tests/aux_kernels/element_normal_except1.i)

# The PorousFlowElementNormal is used with a nodal AuxVariable to illustrate that an error is produced
[Mesh]
  [gmg]
    type = GeneratedMeshGenerator
    dim = 1
    nx = 1
  []
[]

[Variables]
  [dummy]
  []
[]

[Kernels]
  [dummy]
    type = Diffusion
    variable = dummy
  []
[]

[AuxVariables]
  [nodal_aux]
  []
[]

[AuxKernels]
  [nodal_aux]
    type = PorousFlowElementNormal
    variable = nodal_aux
    component = x
  []
[]

[Executioner]
  type = Transient
[]

(modules/porous_flow/test/tests/aux_kernels/element_normal_1D_2D.i)

# The PorousFlowElementNormal is used to calculate normal directions
[Mesh]
  [base]
    type = AnnularMeshGenerator
    dmax = 90
    nr = 3
    nt = 1
    rmin = 0
    rmax = 1
  []
  [rotate]
    type = TransformGenerator
    input = base
    transform = ROTATE
    vector_value = '0 45 0'
  []
  [rmax_block]
    type = LowerDBlockFromSidesetGenerator
    input = rotate
    sidesets = rmax
    new_block_name = rmax
  []
  [dmax_block]
    type = LowerDBlockFromSidesetGenerator
    input = rmax_block
    sidesets = dmax
    new_block_name = dmax
  []
[]

[Variables]
  [dummy]
  []
[]

[Kernels]
  [dummy]
    type = Diffusion
    variable = dummy
  []
[]

[AuxVariables]
  [nx]
    family = MONOMIAL
    order = CONSTANT
  []
  [ny]
    family = MONOMIAL
    order = CONSTANT
  []
  [nz]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [nx]
    type = PorousFlowElementNormal
    variable = nx
    component = x
    1D_perp = '0 1 0'
  []
  [ny]
    type = PorousFlowElementNormal
    variable = ny
    component = y
    1D_perp = '0 1 0'
  []
  [nz]
    type = PorousFlowElementNormal
    variable = nz
    component = z
    1D_perp = '0 1 0'
  []
[]

[Postprocessors]
  [n2Dx]
    type = ElementAverageValue
    variable = nx
    block = '0 1'
  []
  [n2Dy]
    type = ElementAverageValue
    variable = ny
    block = '0 1'
  []
  [n2Dz]
    type = ElementAverageValue
    variable = nz
    block = '0 1'
  []
  [nrmaxx]
    type = ElementAverageValue
    variable = nx
    block = rmax
  []
  [nrmaxy]
    type = ElementAverageValue
    variable = ny
    block = rmax
  []
  [nrmaxz]
    type = ElementAverageValue
    variable = nz
    block = rmax
  []
  [ndmaxx]
    type = ElementAverageValue
    variable = nx
    block = dmax
  []
  [ndmaxy]
    type = ElementAverageValue
    variable = ny
    block = dmax
  []
  [ndmaxz]
    type = ElementAverageValue
    variable = nz
    block = dmax
  []
[]

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

[Outputs]
  csv = true
[]

(modules/porous_flow/examples/multiapp_fracture_flow/3dFracture/fracture_only_aperture_changing.i)

# Cold water injection into one side of the fracture network, and production from the other side
injection_rate = 10 # kg/s

[Mesh]
  uniform_refine = 0
  [cluster34]
    type = FileMeshGenerator
    file = 'Cluster_34.exo'
  []
  [injection_node]
    type = BoundingBoxNodeSetGenerator
    input = cluster34
    bottom_left = '-1000 0 -1000'
    top_right = '1000 0.504 1000'
    new_boundary = injection_node
  []
[]

[GlobalParams]
  PorousFlowDictator = dictator
  gravity = '0 0 -9.81E-6' # Note the value, because of pressure_unit
[]

[Variables]
  [frac_P]
    scaling = 1E6
  []
  [frac_T]
    initial_condition = 473
  []
[]

[ICs]
  [frac_P]
    type = FunctionIC
    variable = frac_P
    function = insitu_pp
  []
[]

[PorousFlowFullySaturated]
  coupling_type = ThermoHydro
  porepressure = frac_P
  temperature = frac_T
  fp = water
  pressure_unit = MPa
[]

[Kernels]
  [toMatrix]
    type = PorousFlowHeatMassTransfer
    variable = frac_T
    v = transferred_matrix_T
    transfer_coefficient = heat_transfer_coefficient
    save_in = joules_per_s
  []
[]

[AuxVariables]
  [heat_transfer_coefficient]
    family = MONOMIAL
    order = CONSTANT
    initial_condition = 0.0
  []
  [transferred_matrix_T]
    initial_condition = 473
  []
  [joules_per_s]
  []
  [normal_dirn_x]
    family = MONOMIAL
    order = CONSTANT
  []
  [normal_dirn_y]
    family = MONOMIAL
    order = CONSTANT
  []
  [normal_dirn_z]
    family = MONOMIAL
    order = CONSTANT
  []
  [enclosing_element_normal_length]
    family = MONOMIAL
    order = CONSTANT
  []
  [enclosing_element_normal_thermal_cond]
    family = MONOMIAL
    order = CONSTANT
  []
  [aperture]
    family = MONOMIAL
    order = CONSTANT
  []
  [perm_times_app]
    family = MONOMIAL
    order = CONSTANT
  []
  [density]
    family = MONOMIAL
    order = CONSTANT
  []
  [viscosity]
    family = MONOMIAL
    order = CONSTANT
  []
  [insitu_pp]
  []
[]

[AuxKernels]
  [normal_dirn_x_auxk]
    type = PorousFlowElementNormal
    variable = normal_dirn_x
    component = x
  []
  [normal_dirn_y]
    type = PorousFlowElementNormal
    variable = normal_dirn_y
    component = y
  []
  [normal_dirn_z]
    type = PorousFlowElementNormal
    variable = normal_dirn_z
    component = z
  []
  [heat_transfer_coefficient_auxk]
    type = ParsedAux
    variable = heat_transfer_coefficient
    args = 'enclosing_element_normal_length enclosing_element_normal_thermal_cond'
    constant_names = h_s
    constant_expressions = 1E3 # should be much bigger than thermal_conductivity / L ~ 1
    function = 'if(enclosing_element_normal_length = 0, 0, h_s * enclosing_element_normal_thermal_cond * 2 * enclosing_element_normal_length / (h_s * enclosing_element_normal_length * enclosing_element_normal_length + enclosing_element_normal_thermal_cond * 2 * enclosing_element_normal_length))'
  []
  [aperture]
    type = PorousFlowPropertyAux
    variable = aperture
    property = porosity
  []
  [perm_times_app]
    type = PorousFlowPropertyAux
    variable = perm_times_app
    property = permeability
    row = 0
    column = 0
  []
  [density]
    type = PorousFlowPropertyAux
    variable = density
    property = density
    phase = 0
  []
  [viscosity]
    type = PorousFlowPropertyAux
    variable = viscosity
    property = viscosity
    phase = 0
  []
  [insitu_pp]
    type = FunctionAux
    execute_on = initial
    variable = insitu_pp
    function = insitu_pp
  []
[]

[BCs]
  [inject_heat]
    type = DirichletBC
    boundary = injection_node
    variable = frac_T
    value = 373
  []
[]

[DiracKernels]
  [inject_fluid]
    type = PorousFlowPointSourceFromPostprocessor
    mass_flux = ${injection_rate}
    point = '58.8124 0.50384 74.7838'
    variable = frac_P
  []
  [withdraw_fluid]
    type = PorousFlowPeacemanBorehole
    SumQuantityUO = kg_out_uo
    bottom_p_or_t = 10.6 # 1MPa + approx insitu at production point, to prevent aperture closing due to low porepressures
    character = 1
    line_length = 1
    point_file = production.xyz
    unit_weight = '0 0 0'
    fluid_phase = 0
    use_mobility = true
    variable = frac_P
  []
  [withdraw_heat]
    type = PorousFlowPeacemanBorehole
    SumQuantityUO = J_out_uo
    bottom_p_or_t = 10.6 # 1MPa + approx insitu at production point, to prevent aperture closing due to low porepressures
    character = 1
    line_length = 1
    point_file = production.xyz
    unit_weight = '0 0 0'
    fluid_phase = 0
    use_mobility = true
    use_enthalpy = true
    variable = frac_T
  []
[]

[UserObjects]
  [kg_out_uo]
    type = PorousFlowSumQuantity
  []
  [J_out_uo]
    type = PorousFlowSumQuantity
  []
[]

[Modules]
  [FluidProperties]
    [true_water]
      type = Water97FluidProperties
    []
    [water]
      type = TabulatedFluidProperties
      fp = true_water
      temperature_min = 275 # K
      temperature_max = 600
      interpolated_properties = 'density viscosity enthalpy internal_energy'
      fluid_property_file = water97_tabulated.csv
    []
  []
[]

[Materials]
  [porosity]
    type = PorousFlowPorosityLinear
    porosity_ref = 1E-4 # fracture porosity = 1.0, but must include fracture aperture of 1E-4 at P = insitu_pp
    P_ref = insitu_pp
    P_coeff = 1E-3 # this is in metres/MPa, ie for P_ref = 1/P_coeff, the aperture becomes 1 metre
    porosity_min = 1E-5
  []
  [permeability]
    type = PorousFlowPermeabilityKozenyCarman
    k0 = 1E-15  # fracture perm = 1E-11 m^2, but must include fracture aperture of 1E-4
    poroperm_function = kozeny_carman_phi0
    m = 0
    n = 3
    phi0 = 1E-4
  []
  [internal_energy]
    type = PorousFlowMatrixInternalEnergy
    density = 2700 # kg/m^3
    specific_heat_capacity = 0 # basically no rock inside the fracture
  []
  [aq_thermal_conductivity]
    type = PorousFlowThermalConductivityIdeal
    dry_thermal_conductivity = '0.6E-4 0 0  0 0.6E-4 0  0 0 0.6E-4' # thermal conductivity of water times fracture aperture.  This should increase linearly with aperture, but is set constant in this model
  []
[]

[Functions]
  [kg_rate]
    type = ParsedFunction
    vals = 'dt kg_out'
    vars = 'dt kg_out'
    value = 'kg_out/dt'
  []
  [insitu_pp]
    type = ParsedFunction
    value = '10 - 0.847E-2 * z' # Approximate hydrostatic in MPa
  []
[]

[Postprocessors]
  [dt]
    type = TimestepSize
    outputs = 'none'
  []
  [kg_out]
    type = PorousFlowPlotQuantity
    uo = kg_out_uo
  []
  [kg_per_s]
    type = FunctionValuePostprocessor
    function = kg_rate
  []
  [J_out]
    type = PorousFlowPlotQuantity
    uo = J_out_uo
  []
  [TK_out]
    type = PointValue
    variable = frac_T
    point = '101.705 160.459 39.5722'
  []
  [P_out]
    type = PointValue
    variable = frac_P
    point = '101.705 160.459 39.5722'
  []
  [P_in]
    type = PointValue
    variable = frac_P
    point = '58.8124 0.50384 74.7838'
  []
[]

[VectorPostprocessors]
  [heat_transfer_rate]
    type = NodalValueSampler
    outputs = none
    sort_by = id
    variable = joules_per_s
  []
[]

[Preconditioning]
  [entire_jacobian]
    type = SMP
    full = true
    petsc_options_iname = '-pc_type -sub_pc_type -sub_pc_factor_shift_type -pc_asm_overlap'
    petsc_options_value = ' asm      lu           NONZERO                   2             '
  []
[]

[Executioner]
  type = Transient
  solve_type = NEWTON
  [TimeStepper]
    type = IterationAdaptiveDT
    dt = 1
    optimal_iterations = 10
    growth_factor = 1.5
    timestep_limiting_postprocessor = 1E8
  []
  end_time = 1E8
  nl_abs_tol = 1E-3
  nl_max_its = 20
[]

[Outputs]
  print_linear_residuals = false
  csv = true
  [ex]
    type = Exodus
    sync_times = '1 10 100 200 300 400 500 600 700 800 900 1000 1100 1200 1300 1400 1500 1600 1700 1800 1900 2000 2100 2200 2300 2400 2500 2600 2700 2800 2900 3000 3100 3200 3300 3400 3500 3600 3700 3800 3900 4000 4100 4200 4300 4400 4500 4600 4700 4800 4900 5000 5100 5200 5300 5400 5500 5600 5700 5800 5900 6000 6100 6200 6300 6400 6500 6600 6700 6800 6900 7000 7100 7200 7300 7400 7500 7600 7700 7800 7900 8000 8100 8200 8300 8400 8500 8600 8700 8800 8900 9000 10000 11000 12000 13000 14000 15000 16000 17000 18000 19000 20000 30000 50000 70000 100000 200000 300000 400000 500000 600000 700000 800000 900000 1000000 1100000 1200000 1300000 1400000 1500000 1600000 1700000 1800000 1900000 2000000 2100000 2200000 2300000 2400000 2500000 2600000 2700000 2800000 2900000'
    sync_only = true
  []
[]

(modules/porous_flow/test/tests/aux_kernels/element_normal_except2.i)

# The PorousFlowElementNormal is used with a zero 1D_perp vector to illustrate that an error is produced
[Mesh]
  [gmg]
    type = GeneratedMeshGenerator
    dim = 1
    nx = 1
  []
[]

[Variables]
  [dummy]
  []
[]

[Kernels]
  [dummy]
    type = Diffusion
    variable = dummy
  []
[]

[AuxVariables]
  [n]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [nodal_aux]
    type = PorousFlowElementNormal
    variable = n
    component = x
    1D_perp = '0 0 0'
  []
[]

[Executioner]
  type = Transient
[]

(modules/porous_flow/test/tests/aux_kernels/element_normal_2D_3D.i)

# The PorousFlowElementNormal is used to calculate normal directions
[Mesh]
  [base]
    type = AnnularMeshGenerator
    dmax = 90
    nr = 1
    nt = 1
    rmin = 0.1
    rmax = 1
  []
  [make3D]
    type = MeshExtruderGenerator
    input = base
    bottom_sideset = bottom
    extrusion_vector = '0 0 1'
    top_sideset = top
  []
  [rmax_block]
    type = LowerDBlockFromSidesetGenerator
    input = make3D
    sidesets = rmax
    new_block_name = rmax
  []
  [top_block]
    type = LowerDBlockFromSidesetGenerator
    input = rmax_block
    sidesets = top
    new_block_name = top
  []
[]

[Variables]
  [dummy]
  []
[]

[Kernels]
  [dummy]
    type = Diffusion
    variable = dummy
  []
[]

[AuxVariables]
  [nx]
    family = MONOMIAL
    order = CONSTANT
  []
  [ny]
    family = MONOMIAL
    order = CONSTANT
  []
  [nz]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [nx]
    type = PorousFlowElementNormal
    variable = nx
    component = x
    3D_default = '-3 4 5'
  []
  [ny]
    type = PorousFlowElementNormal
    variable = ny
    component = y
    3D_default = '-3 4 5'
  []
  [nz]
    type = PorousFlowElementNormal
    variable = nz
    component = z
    3D_default = '-3 4 5'
  []
[]

[Postprocessors]
  [n3Dx]
    type = ElementAverageValue
    variable = nx
    block = 0
  []
  [n3Dy]
    type = ElementAverageValue
    variable = ny
    block = 0
  []
  [n3Dz]
    type = ElementAverageValue
    variable = nz
    block = 0
  []
  [nrmaxx]
    type = ElementAverageValue
    variable = nx
    block = rmax
  []
  [nrmaxy]
    type = ElementAverageValue
    variable = ny
    block = rmax
  []
  [nrmaxz]
    type = ElementAverageValue
    variable = nz
    block = rmax
  []
  [ntopx]
    type = ElementAverageValue
    variable = nx
    block = top
  []
  [ntopy]
    type = ElementAverageValue
    variable = ny
    block = top
  []
  [ntopz]
    type = ElementAverageValue
    variable = nz
    block = top
  []
[]

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

[Outputs]
  csv = true
  exodus = true
[]

(modules/porous_flow/test/tests/aux_kernels/element_normal_except3.i)

# The PorousFlowElementNormal is used with a zero 3D_default vector to illustrate that an error is produced
[Mesh]
  [gmg]
    type = GeneratedMeshGenerator
    dim = 1
    nx = 1
  []
[]

[Variables]
  [dummy]
  []
[]

[Kernels]
  [dummy]
    type = Diffusion
    variable = dummy
  []
[]

[AuxVariables]
  [n]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [nodal_aux]
    type = PorousFlowElementNormal
    variable = n
    component = x
    3D_default = '0 0 0'
  []
[]

[Executioner]
  type = Transient
[]

Input Parameters
Input Files

Install MOOSE

New Users

Examples and Tutorials

Application Usage

Physics and Syntax

Application Development

Framework Development

MOOSEDocs

Infrastructure

Questions

Information and Tools

INL Applications and Remote Access