- inputThe mesh we want to modify
C++ Type:MeshGeneratorName
Controllable:No
Description:The mesh we want to modify
ParsedNodeTransformGenerator
Applies a transform to a the x,y,z coordinates of a Mesh
Overview
The ParsedNodeTransformGenerator generator allows the user to specify parsed expressions to compute the new positions of all mesh nodes as the function of their old positions. The old node positions components are made available as function symbols x, y, and z. The new node position components are determined by the "x_function", "y_function", and "z_function" parameters. The parsed expression syntax available is the same as used in ParsedFunction and ParsedMaterial.
Input Parameters
- constant_expressionsVector of values for the constants in constant_names (can be an FParser expression)
C++ Type:std::vector<std::string>
Controllable:No
Description:Vector of values for the constants in constant_names (can be an FParser expression)
- constant_namesVector of constants used in the parsed function
C++ Type:std::vector<std::string>
Controllable:No
Description:Vector of constants used in the parsed function
- epsilon0Fuzzy comparison tolerance
Default:0
C++ Type:Real
Unit:(no unit assumed)
Controllable:No
Description:Fuzzy comparison tolerance
- x_functionxFunction for the updated x component of the node
Default:x
C++ Type:ParsedFunctionExpression
Unit:(no unit assumed)
Controllable:No
Description:Function for the updated x component of the node
- y_functionyFunction for the updated y component of the node
Default:y
C++ Type:ParsedFunctionExpression
Unit:(no unit assumed)
Controllable:No
Description:Function for the updated y component of the node
- z_functionzFunction for the updated z component of the node
Default:z
C++ Type:ParsedFunctionExpression
Unit:(no unit assumed)
Controllable:No
Description:Function for the updated z component of the node
Optional Parameters
- disable_fpoptimizerFalseDisable the function parser algebraic optimizer
Default:False
C++ Type:bool
Controllable:No
Description:Disable the function parser algebraic optimizer
- enable_ad_cacheTrueEnable caching of function derivatives for faster startup time
Default:True
C++ Type:bool
Controllable:No
Description:Enable caching of function derivatives for faster startup time
- enable_auto_optimizeTrueEnable automatic immediate optimization of derivatives
Default:True
C++ Type:bool
Controllable:No
Description:Enable automatic immediate optimization of derivatives
- enable_jitTrueEnable just-in-time compilation of function expressions for faster evaluation
Default:True
C++ Type:bool
Controllable:No
Description:Enable just-in-time compilation of function expressions for faster evaluation
- evalerror_behaviornanWhat to do if evaluation error occurs. Options are to pass a nan, pass a nan with a warning, throw a error, or throw an exception
Default:nan
C++ Type:MooseEnum
Options:nan, nan_warning, error, exception
Controllable:No
Description:What to do if evaluation error occurs. Options are to pass a nan, pass a nan with a warning, throw a error, or throw an exception
Parsed Expression Advanced Parameters
- enableTrueSet the enabled status of the MooseObject.
Default:True
C++ Type:bool
Controllable:No
Description:Set the enabled status of the MooseObject.
- save_with_nameKeep the mesh from this mesh generator in memory with the name specified
C++ Type:std::string
Controllable:No
Description:Keep the mesh from this mesh generator in memory with the name specified
Advanced Parameters
- nemesisFalseWhether or not to output the mesh file in the nemesisformat (only if output = true)
Default:False
C++ Type:bool
Controllable:No
Description:Whether or not to output the mesh file in the nemesisformat (only if output = true)
- outputFalseWhether or not to output the mesh file after generating the mesh
Default:False
C++ Type:bool
Controllable:No
Description:Whether or not to output the mesh file after generating the mesh
- show_infoFalseWhether or not to show mesh info after generating the mesh (bounding box, element types, sidesets, nodesets, subdomains, etc)
Default:False
C++ Type:bool
Controllable:No
Description:Whether or not to show mesh info after generating the mesh (bounding box, element types, sidesets, nodesets, subdomains, etc)
Debugging Parameters
Input Files
- (modules/contact/test/tests/3d-mortar-contact/penalty-sparsity.i)
- (test/tests/meshgenerators/xyz_delaunay_generator/xyzdelaunay_mesh_generator_3d.i)
- (modules/contact/test/tests/nodal_normal_derivatives/curved_3d_action.i)
- (test/tests/meshgenerators/xyz_delaunay_generator/xyzdelaunay_mesh_generator_2d.i)
- (modules/navier_stokes/test/tests/finite_volume/ins/mms/linear-segregated/porosity-jump-traction/porosity-jump-traction.i)
- (modules/navier_stokes/test/tests/finite_volume/pins/mms/linear-segregated/interface-reconstruction/interface-reconstruction.i)
- (test/tests/meshgenerators/manifold_subdomain/cone.i)
- (modules/navier_stokes/test/tests/finite_volume/ins/turbulence/lid-driven/segregated/lid-driven-turb-capped.i)
- (test/tests/meshgenerators/xyz_delaunay_generator/xyzdelaunay_quadratic.i)
- (test/tests/meshgenerators/xyz_delaunay_generator/err_xyzdelaunay_with_holes_mix.i)
- (test/tests/meshgenerators/xyz_delaunay_generator/xyzdelaunay_with_holes_1d.i)
- (test/tests/meshgenerators/xyz_delaunay_generator/xyzdelaunay_with_holes_2d.i)
- (test/tests/meshgenerators/compute_node_position/3d.i)
- (test/tests/meshgenerators/xyz_delaunay_generator/xyzdelaunay_stitching.i)
- (test/tests/meshgenerators/xyz_delaunay_generator/xyzdelaunay_nested.i)
- (modules/navier_stokes/test/tests/finite_volume/ins/turbulence/lid-driven/newton_physics/lid-driven-turb-capped-physics.i)
- (modules/contact/test/tests/dual_mortar/mortar_mechanical_contact_force_balance.i)
- (test/tests/meshgenerators/compute_node_position/2d.i)
- (test/tests/meshgenerators/advanced_extruder_generator/extrude_along_normals.i)
- (modules/navier_stokes/test/tests/finite_volume/pins/mms/linear-segregated/smooth-properties/smooth-properties.i)
- (test/tests/meshgenerators/xyz_delaunay_generator/xyzdelaunay_smoothed.i)
- (test/tests/meshgenerators/advanced_extruder_generator/extrude_along_normals_1d.i)
- (test/tests/meshgenerators/xyz_delaunay_generator/xyzdelaunay_with_holes_3d.i)
- (modules/navier_stokes/test/tests/finite_volume/pins/mms/linear-segregated/hydrostatic-jump/hydrostatic-jump.i)
x_function
Default:x
C++ Type:ParsedFunctionExpression
Unit:(no unit assumed)
Controllable:No
Description:Function for the updated x component of the node
y_function
Default:y
C++ Type:ParsedFunctionExpression
Unit:(no unit assumed)
Controllable:No
Description:Function for the updated y component of the node
z_function
Default:z
C++ Type:ParsedFunctionExpression
Unit:(no unit assumed)
Controllable:No
Description:Function for the updated z component of the node
(modules/contact/test/tests/3d-mortar-contact/penalty-sparsity.i)
[GlobalParams]
displacements = 'disp_x disp_y disp_z'
[]
[Mesh]
[top]
type = GeneratedMeshGenerator
dim = 3
xmin = -0.25
xmax = 0.25
ymin = -0.25
ymax = 0.25
zmin = -0.25
zmax = 0.25
elem_type = TET10
boundary_name_prefix = top
[]
[top_id]
type = SubdomainIDGenerator
input = top
subdomain_id = 1
[]
[bottom]
type = GeneratedMeshGenerator
dim = 3
xmin = -0.5
xmax = 0.5
ymin = -0.5
ymax = 0.5
zmin = -0.3
zmax = -0.25
elem_type = TET10
boundary_name_prefix = bottom
boundary_id_offset = 10
[]
[bottom_id]
type = SubdomainIDGenerator
input = bottom
subdomain_id = 2
[]
[combined]
type = MeshCollectionGenerator
inputs = 'top_id bottom_id'
[]
[Partitioner]
type = GridPartitioner
# Three slabs across the interface put the secondary faces around some contact nodes on
# processes other than the node owner
nx = 3
[]
[curve]
type = ParsedNodeTransformGenerator
input = combined
x_function = x
y_function = y
z_function = 'z + 0.04 * x * x'
[]
[]
[Variables]
[disp_x]
order = SECOND
[]
[disp_y]
order = SECOND
[]
[disp_z]
order = SECOND
[]
[]
[Kernels]
[disp_x]
type = Diffusion
variable = disp_x
[]
[disp_y]
type = Diffusion
variable = disp_y
[]
[disp_z]
type = Diffusion
variable = disp_z
[]
[]
# GeneratedMeshGenerator in 3D: 'back' is the zmin face and 'front' the zmax face
[Contact]
[mortar]
primary = bottom_front
secondary = top_back
formulation = mortar_penalty
model = frictionless
penalty = 1e2
[]
[]
[Problem]
# The test fails if contact assembles a Jacobian entry outside the preallocated sparsity pattern
error_on_jacobian_nonzero_reallocation = true
[]
[Executioner]
type = Steady
solve_type = NEWTON
# Assembling the Jacobian once is all this test checks, so a single forced Newton step suffices
# and the tolerance is loose enough that the solve converges after it
nl_forced_its = 1
nl_max_its = 1
nl_abs_tol = 1e-3
[]
(test/tests/meshgenerators/xyz_delaunay_generator/xyzdelaunay_mesh_generator_3d.i)
[Mesh]
[gmg]
type = GeneratedMeshGenerator
dim = 3
nx = 1
ny = 1
nz = 1
[]
[outer_bdy]
type = ParsedNodeTransformGenerator
input = gmg
x_function = "x"
y_function = "y"
z_function = "z+x*y*z"
[]
[triang]
type = XYZDelaunayGenerator
boundary = 'outer_bdy'
# Let NetGen know interior points are okay
desired_volume = 100000
[]
[]
[Executioner]
type = Steady
[]
[Postprocessors]
[volume]
type = VolumePostprocessor
[]
[]
[Problem]
solve = false
[]
[Outputs]
[output]
type = CSV
file_base = 'xyzdelaunay_mesh_generator_out'
[]
[]
(modules/contact/test/tests/nodal_normal_derivatives/curved_3d_action.i)
!include ../3d-mortar-contact/frictionless-mortar-3d-action.i
overclosure = 0.001
[Mesh]
[top_curve]
type = ParsedNodeTransformGenerator
input = top_block_id
x_function = x
y_function = y
z_function = 'z + 0.04 * x * x + 0.03 * y * y + 0.02 * x * y'
[]
[bottom_curve]
type = ParsedNodeTransformGenerator
input = bottom_block_change_boundary_id
x_function = x
y_function = y
z_function = 'z + 0.04 * x * x + 0.03 * y * y + 0.02 * x * y'
[]
[combined]
inputs := 'top_curve bottom_curve'
[]
[]
[ICs]
[disp_z]
value := '-${overclosure}'
[]
[normal_lm]
type = ConstantIC
variable = mortar_normal_lm
block = mortar_secondary_subdomain
value = 1
[]
[]
[Contact]
[mortar]
model := coulomb
friction_coefficient = 0.25
use_dual = true
[]
[]
[BCs]
active = 'botx boty botz move_top_x move_top_y move_top_z'
[move_top_x]
type = FunctionDirichletBC
variable = disp_x
boundary = top_top
function = '0.001 * t'
[]
[move_top_y]
type = FunctionDirichletBC
variable = disp_y
boundary = top_top
function = '0.0015 * t'
[]
[move_top_z]
type = FunctionDirichletBC
variable = disp_z
boundary = top_top
function = '-${overclosure} * t'
[]
[]
[Executioner]
solve_type := NEWTON
end_time := 1
dt := 1
nl_abs_tol := 1e-10
nl_rel_tol := 1e-8
nl_max_its := 25
line_search := none
[]
[Postprocessors]
active := num_nl
[]
[VectorPostprocessors]
active = ''
[]
[Outputs]
exodus := false
[]
(test/tests/meshgenerators/xyz_delaunay_generator/xyzdelaunay_mesh_generator_2d.i)
[Mesh]
[fmg]
type = FileMeshGenerator
file = 'gold/2d_cube.e'
[]
[outer_bdy]
type = ParsedNodeTransformGenerator
input = fmg
x_function = "x"
y_function = "y"
z_function = "z+x*y*z"
[]
[triang]
type = XYZDelaunayGenerator
boundary = 'outer_bdy'
# Let NetGen know interior points are okay
desired_volume = 100000
[]
[]
[Executioner]
type = Steady
[]
[Postprocessors]
[volume]
type = VolumePostprocessor
[]
[]
[Problem]
solve = false
[]
[Outputs]
[output]
type = CSV
file_base = 'xyzdelaunay_mesh_generator_out'
[]
[]
(modules/navier_stokes/test/tests/finite_volume/ins/mms/linear-segregated/porosity-jump-traction/porosity-jump-traction.i)
rho = 1
mu = 1
eps_left = 0.4
eps_right = 0.8
interface = 0.5
skew = 0.35
normal_velocity = 0
tangential_velocity = 1
tangential_gradient = 0
tangential_curvature = 0.5
shear_traction = 2
# In interface-normal coordinates (r,t), the manufactured velocity is
# v_n = normal_velocity + tangential_gradient*t and
# v_t = tangential_velocity + (shear_traction/mu - tangential_gradient)*r
# + tangential_curvature*r^2. It is divergence-free and
# mu*(d(v_t)/dr + d(v_n)/dt) = shear_traction on both sides of the porosity interface.
[Problem]
linear_sys_names = 'u_system v_system pressure_system'
previous_nl_solution_required = true
[]
[Mesh]
[gen]
type = GeneratedMeshGenerator
dim = 2
nx = 4
ny = 4
[]
[right]
type = ParsedSubdomainMeshGenerator
input = gen
combinatorial_geometry = 'x > ${interface}'
block_id = 1
block_name = right
[]
[left]
type = ParsedSubdomainMeshGenerator
input = right
combinatorial_geometry = 'x < ${interface}'
block_id = 2
block_name = left
[]
[skew]
type = ParsedNodeTransformGenerator
input = left
x_function = 'x + ${skew} * y'
[]
[]
[UserObjects]
[rc]
type = PorousRhieChowMassFlux
u = vel_x
v = vel_y
pressure = pressure
rho = ${rho}
porosity = porosity
p_diffusion_kernel = p_diffusion
pressure_projection_method = consistent
[]
[]
[Variables]
[vel_x]
type = MooseLinearVariableFVReal
solver_sys = u_system
initial_condition = 0
[]
[vel_y]
type = MooseLinearVariableFVReal
solver_sys = v_system
initial_condition = 0
[]
[pressure]
type = MooseLinearVariableFVReal
solver_sys = pressure_system
initial_condition = 0
[]
[]
[FVInterpolationMethods]
[average]
type = FVGeometricAverage
[]
[]
[LinearFVKernels]
[u_advection_stress]
type = LinearPWCNSFVMomentumFlux
variable = vel_x
advected_interp_method_name = average
mu = dynamic_viscosity
u = vel_x
v = vel_y
momentum_component = x
rhie_chow_user_object = rc
use_nonorthogonal_correction = true
use_deviatoric_terms = true
[]
[v_advection_stress]
type = LinearPWCNSFVMomentumFlux
variable = vel_y
advected_interp_method_name = average
mu = dynamic_viscosity
u = vel_x
v = vel_y
momentum_component = y
rhie_chow_user_object = rc
use_nonorthogonal_correction = true
use_deviatoric_terms = true
[]
[u_pressure]
type = LinearPWCNSFVMomentumPressure
variable = vel_x
pressure = pressure
porosity = porosity
momentum_component = x
[]
[v_pressure]
type = LinearPWCNSFVMomentumPressure
variable = vel_y
pressure = pressure
porosity = porosity
momentum_component = y
[]
[u_forcing]
type = LinearFVSource
variable = vel_x
source_density = forcing_u
[]
[v_forcing]
type = LinearFVSource
variable = vel_y
source_density = forcing_v
[]
[p_diffusion]
type = LinearFVPressureCorrectionDiffusion
variable = pressure
diffusion_tensor = Ainv
use_nonorthogonal_correction = true
use_nonorthogonal_correction_on_boundary = true
[]
[HbyA_divergence]
type = LinearFVDivergence
variable = pressure
face_flux = HbyA
force_boundary_execution = true
[]
[]
[LinearFVBCs]
[velocity_x]
type = LinearFVAdvectionDiffusionFunctorDirichletBC
boundary = 'left right top bottom'
variable = vel_x
functor = exact_u
[]
[velocity_y]
type = LinearFVAdvectionDiffusionFunctorDirichletBC
boundary = 'left right top bottom'
variable = vel_y
functor = exact_v
[]
[pressure-extrapoaltion]
type = LinearFVPressureFluxBC
boundary = 'left right top bottom'
variable = pressure
HbyA_flux = HbyA
Ainv = Ainv
rho = ${rho}
u = vel_x
v = vel_y
# The two-term boundary pressure expansion leaves an O(1) pressure error in the boundary
# cells on this nonorthogonal mesh, which limits the L2 pressure slope to about 0.5.
use_two_term_expansion = false
[]
[]
[FunctorMaterials]
[viscosity]
type = GenericFunctorMaterial
prop_names = dynamic_viscosity
prop_values = ${mu}
[]
[porosity_left]
type = GenericFunctorMaterial
block = left
prop_names = porosity
prop_values = ${eps_left}
[]
[porosity_right]
type = GenericFunctorMaterial
block = right
prop_names = porosity
prop_values = ${eps_right}
[]
[]
[Functions]
[exact_u]
type = ParsedFunction
expression = '(vn+skew*vt)/sqrt(1+skew^2)'
symbol_names = 'skew vn vt'
symbol_values = '${skew} exact_normal_velocity exact_tangential_velocity'
[]
[exact_v]
type = ParsedFunction
expression = '(-skew*vn+vt)/sqrt(1+skew^2)'
symbol_names = 'skew vn vt'
symbol_values = '${skew} exact_normal_velocity exact_tangential_velocity'
[]
[exact_normal_velocity]
type = ParsedFunction
expression = 'U+b*(skew*x+y)/sqrt(1+skew^2)'
symbol_names = 'skew U b'
symbol_values = '${skew} ${normal_velocity} ${tangential_gradient}'
[]
[exact_tangential_velocity]
type = ParsedFunction
expression = 'Vt+(q/mu-b)*(x-skew*y-interface)/sqrt(1+skew^2)'
'+c*((x-skew*y-interface)/sqrt(1+skew^2))^2'
symbol_names = 'interface skew mu q b Vt c'
symbol_values = '${interface} ${skew} ${mu} ${shear_traction} ${tangential_gradient} ${tangential_velocity} ${tangential_curvature}'
[]
[tangential_velocity_derivative]
type = ParsedFunction
expression = 'q/mu-b+2*c*(x-skew*y-interface)/sqrt(1+skew^2)'
symbol_names = 'interface skew mu q b c'
symbol_values = '${interface} ${skew} ${mu} ${shear_traction} ${tangential_gradient} ${tangential_curvature}'
[]
[forcing_u]
type = ParsedFunction
expression = '(b*vt+skew*(dvtdr*vn-2*mu*c))/sqrt(1+skew^2)'
symbol_names = 'skew mu vn vt dvtdr b c'
symbol_values = '${skew} ${mu} exact_normal_velocity exact_tangential_velocity tangential_velocity_derivative ${tangential_gradient} ${tangential_curvature}'
[]
[forcing_v]
type = ParsedFunction
expression = '(-skew*b*vt+dvtdr*vn-2*mu*c)/sqrt(1+skew^2)'
symbol_names = 'skew mu vn vt dvtdr b c'
symbol_values = '${skew} ${mu} exact_normal_velocity exact_tangential_velocity tangential_velocity_derivative ${tangential_gradient} ${tangential_curvature}'
[]
[]
[Executioner]
type = SIMPLE
momentum_l_abs_tol = 1e-11
pressure_l_abs_tol = 1e-11
momentum_l_max_its = 50
pressure_l_max_its = 50
momentum_l_tol = 0
pressure_l_tol = 0
rhie_chow_user_object = rc
momentum_systems = 'u_system v_system'
pressure_system = pressure_system
momentum_equation_relaxation = 0.7
pressure_variable_relaxation = 0.5
num_iterations = 5000
pressure_absolute_tolerance = 1e-10
momentum_absolute_tolerance = 1e-10
momentum_petsc_options_iname = '-pc_type -pc_hypre_type'
momentum_petsc_options_value = 'hypre boomeramg'
pressure_petsc_options_iname = '-pc_type -pc_hypre_type'
pressure_petsc_options_value = 'hypre boomeramg'
print_fields = false
pin_pressure = true
pressure_pin_value = 0
pressure_pin_point = '0.425 0.5 0'
[]
[Outputs]
exodus = false
[csv]
type = CSV
execute_on = FINAL
[]
[]
[Postprocessors]
[h]
type = AverageElementSize
outputs = csv
execute_on = FINAL
[]
[L2u]
type = ElementL2FunctorError
approximate = vel_x
exact = exact_u
outputs = csv
execute_on = FINAL
[]
[L2v]
type = ElementL2FunctorError
approximate = vel_y
exact = exact_v
outputs = csv
execute_on = FINAL
[]
[L2p]
type = ElementL2FunctorError
approximate = pressure
exact = 0
outputs = csv
execute_on = FINAL
[]
[]
(modules/navier_stokes/test/tests/finite_volume/pins/mms/linear-segregated/interface-reconstruction/interface-reconstruction.i)
# Manufactured pressure-baffle problem whose superficial velocity is linear on each side of the
# baffle. In coordinates normal (r) and tangent (t) to the interface:
# - rho * U_r = mass_flux, so mass is conserved;
# - U_t = eps_s * tangential_velocity + tangential_slope_s * r, so the interstitial tangential
# velocity U_t / eps is continuous at r = 0 while the one-sided slopes may differ.
# The forcing balances advection and reaction exactly, so the pressure is constant on each side.
# Its jump is the BernoulliFormLossPressureJump with side velocities mass_flux / (rho eps_s):
# p_right - p_left = mass_flux^2 / (2 rho) * (1 / eps_left^2 - 1 / eps_right^2).
# With viscosity, the baffle transmits only a shear traction, and only from a clear side (unit
# porosity). Between two clear sides it is continuous, so the slopes must be equal. Two porous
# sides transmit none, so viscous cases with porosity below one on both sides need zero slopes. A
# clear side shears against the superficial velocity of a porous side at the interface, so with
# the clear side on the left the traction balance on both rows requires equal slopes and a
# continuous superficial tangential velocity, eps_left * tangential_velocity =
# eps_right * tangential_velocity, which with a porosity jump means tangential_velocity = 0.
# The normal velocity is constant and carries no viscous stress. A consistent scheme reproduces
# this piecewise-linear solution to round-off on uniform meshes.
rho = 1
eps_left = 1
eps_right = 1
mass_flux = 0.02
mu = 0
reaction = 10
tangential_velocity = 0.1
tangential_slope_left = 0.2
tangential_slope_right = 0.2
interface = 0.5
skew = 0
nx = 8
ny = 8
pressure_gradient_method = reconstructed
nonorthogonal = false
[Problem]
linear_sys_names = 'u_system v_system pressure_system'
previous_nl_solution_required = true
[]
[Mesh]
[generated]
type = GeneratedMeshGenerator
dim = 2
nx = ${nx}
ny = ${ny}
[]
[right]
type = ParsedSubdomainMeshGenerator
input = generated
combinatorial_geometry = 'x > ${interface}'
block_id = 2
block_name = right
[]
[left]
type = ParsedSubdomainMeshGenerator
input = right
combinatorial_geometry = 'x < ${interface}'
block_id = 1
block_name = left
[]
[skew]
type = ParsedNodeTransformGenerator
input = left
x_function = 'x + ${skew} * y'
[]
[baffle]
type = SideSetsBetweenSubdomainsGenerator
input = skew
primary_block = left
paired_block = right
new_boundary = baffle
[]
[]
[FVGradientMethods]
[jump_aware]
type = FVPressureJumpGreenGaussGradient
[]
[velocity_jump_aware]
type = FVVelocityJumpGreenGaussGradient
[]
[reconstructed]
type = FVReconstructedPressureGradient
base_gradient_method = jump_aware
gradient_relaxation = 1
[]
[]
[FVInterpolationMethods]
[average]
type = FVGeometricAverage
[]
[]
[UserObjects]
[pressure_jump]
type = BernoulliFormLossPressureJump
boundary = baffle
porosity = porosity
density = density
[]
[rc]
type = PorousRhieChowMassFlux
u = superficial_u
v = superficial_v
pressure = pressure
rho = density
porosity = porosity
p_diffusion_kernel = p_diffusion
pressure_jump_models = pressure_jump
pressure_projection_method = consistent
[]
[]
[Variables]
[superficial_u]
type = MooseLinearVariableFVReal
solver_sys = u_system
initial_condition = ${mass_flux}
gradient_method = velocity_jump_aware
[]
[superficial_v]
type = MooseLinearVariableFVReal
solver_sys = v_system
initial_condition = ${tangential_velocity}
gradient_method = velocity_jump_aware
[]
[pressure]
type = MooseLinearVariableFVReal
solver_sys = pressure_system
initial_condition = 0
gradient_method = jump_aware
[]
[]
[LinearFVKernels]
[u_advection]
type = LinearPWCNSFVMomentumFlux
variable = superficial_u
advected_interp_method_name = average
mu = viscosity
u = superficial_u
v = superficial_v
momentum_component = x
rhie_chow_user_object = rc
use_nonorthogonal_correction = ${nonorthogonal}
[]
[v_advection]
type = LinearPWCNSFVMomentumFlux
variable = superficial_v
advected_interp_method_name = average
mu = viscosity
u = superficial_u
v = superficial_v
momentum_component = y
rhie_chow_user_object = rc
use_nonorthogonal_correction = ${nonorthogonal}
[]
[u_pressure]
type = LinearPWCNSFVMomentumPressure
variable = superficial_u
pressure = pressure
porosity = porosity
momentum_component = x
gradient_method = ${pressure_gradient_method}
[]
[v_pressure]
type = LinearPWCNSFVMomentumPressure
variable = superficial_v
pressure = pressure
porosity = porosity
momentum_component = y
gradient_method = ${pressure_gradient_method}
[]
[u_source]
type = LinearFVSource
variable = superficial_u
source_density = forcing_u
[]
[u_reaction]
type = LinearFVReaction
variable = superficial_u
coeff = ${reaction}
[]
[v_source]
type = LinearFVSource
variable = superficial_v
source_density = forcing_v
[]
[v_reaction]
type = LinearFVReaction
variable = superficial_v
coeff = ${reaction}
[]
[p_diffusion]
type = LinearFVPressureCorrectionDiffusionJump
variable = pressure
rhie_chow_user_object = rc
use_nonorthogonal_correction = ${nonorthogonal}
[]
[HbyA_divergence]
type = LinearFVDivergence
variable = pressure
face_flux = HbyA
force_boundary_execution = true
[]
[]
[LinearFVBCs]
[velocity_x]
type = LinearFVAdvectionDiffusionFunctorDirichletBC
boundary = 'left right top bottom'
variable = superficial_u
functor = exact_u
[]
[velocity_y]
type = LinearFVAdvectionDiffusionFunctorDirichletBC
boundary = 'left right top bottom'
variable = superficial_v
functor = exact_v
[]
[pressure_flux]
type = LinearFVPressureFluxBC
boundary = 'left right top bottom'
variable = pressure
HbyA_flux = HbyA
Ainv = Ainv
rho = density
u = superficial_u
v = superficial_v
[]
[]
[FunctorMaterials]
[density]
type = ParsedFunctorMaterial
property_name = density
expression = '${rho}'
[]
[porosity]
type = ParsedFunctorMaterial
property_name = porosity
expression = 'if(x-${skew}*y<${interface},${eps_left},${eps_right})'
[]
[viscosity]
type = ParsedFunctorMaterial
property_name = viscosity
expression = '${mu}'
[]
[pressure_error]
type = ParsedFunctorMaterial
property_name = pressure_error
functor_names = 'pressure exact_pressure'
expression = 'pressure-exact_pressure'
[]
[]
[AuxVariables]
[reconstructed_grad_p]
family = MONOMIAL_VEC
order = CONSTANT
[]
[]
[AuxKernels]
[reconstructed_grad_p]
type = LinearFVGradientAux
variable = reconstructed_grad_p
linear_fv_variable = pressure
gradient_method = reconstructed
execute_on = FINAL
[]
[]
[Functions]
[normal_coordinate]
type = ParsedFunction
expression = '(x-skew*y-interface)/sqrt(1+skew^2)'
symbol_names = 'skew interface'
symbol_values = '${skew} ${interface}'
[]
[exact_normal_velocity]
type = ParsedFunction
expression = '${mass_flux}/${rho}'
[]
[exact_tangential_velocity]
type = ParsedFunction
expression = 'velocity*porosity+if(x-skew*y<interface,slope_left,slope_right)*r'
symbol_names = 'skew interface velocity porosity slope_left slope_right r'
symbol_values = '${skew} ${interface} ${tangential_velocity} exact_porosity ${tangential_slope_left} ${tangential_slope_right} normal_coordinate'
[]
[exact_pressure]
type = ParsedFunction
expression = 'if(x-skew*y<interface,0,mass_flux^2/(2*rho)*(1/eps_left^2-1/eps_right^2))'
symbol_names = 'skew interface mass_flux rho eps_left eps_right'
symbol_values = '${skew} ${interface} ${mass_flux} ${rho} ${eps_left} ${eps_right}'
[]
[exact_u]
type = ParsedFunction
expression = '(normal+skew*tangential)/sqrt(1+skew^2)'
symbol_names = 'skew normal tangential'
symbol_values = '${skew} exact_normal_velocity exact_tangential_velocity'
[]
[exact_v]
type = ParsedFunction
expression = '(-skew*normal+tangential)/sqrt(1+skew^2)'
symbol_names = 'skew normal tangential'
symbol_values = '${skew} exact_normal_velocity exact_tangential_velocity'
[]
[forcing_u]
type = ParsedFunction
expression = 'skew*mass_flux*slope/(porosity*sqrt(1+skew^2))+reaction*u'
symbol_names = 'skew interface mass_flux slope porosity reaction u'
symbol_values = '${skew} ${interface} ${mass_flux} tangential_slope exact_porosity ${reaction} exact_u'
[]
[forcing_v]
type = ParsedFunction
expression = 'mass_flux*slope/(porosity*sqrt(1+skew^2))+reaction*v'
symbol_names = 'skew interface mass_flux slope porosity reaction v'
symbol_values = '${skew} ${interface} ${mass_flux} tangential_slope exact_porosity ${reaction} exact_v'
[]
[tangential_slope]
type = ParsedFunction
expression = 'if(x-skew*y<interface,slope_left,slope_right)'
symbol_names = 'skew interface slope_left slope_right'
symbol_values = '${skew} ${interface} ${tangential_slope_left} ${tangential_slope_right}'
[]
[exact_porosity]
type = ParsedFunction
expression = 'if(x-skew*y<interface,eps_left,eps_right)'
symbol_names = 'skew interface eps_left eps_right'
symbol_values = '${skew} ${interface} ${eps_left} ${eps_right}'
[]
[]
[Executioner]
type = SIMPLE
momentum_l_abs_tol = 1e-12
pressure_l_abs_tol = 1e-12
momentum_l_tol = 0
pressure_l_tol = 0
momentum_l_max_its = 100
pressure_l_max_its = 100
rhie_chow_user_object = rc
momentum_systems = 'u_system v_system'
pressure_system = pressure_system
momentum_equation_relaxation = 0.7
pressure_variable_relaxation = 0.5
# A solution that is exact to round-off stalls the normalized residuals near 1e-6 instead of
# meeting the absolute tolerances, so run a fixed number of iterations instead.
num_iterations = 200
continue_on_max_its = true
pressure_absolute_tolerance = 1e-11
momentum_absolute_tolerance = 1e-11
momentum_petsc_options_iname = '-pc_type -pc_hypre_type'
momentum_petsc_options_value = 'hypre boomeramg'
pressure_petsc_options_iname = '-pc_type -pc_hypre_type'
pressure_petsc_options_value = 'hypre boomeramg'
print_fields = false
pin_pressure = true
pressure_pin_value = 0
pressure_pin_point = '0.25 0.5 0'
[]
[Postprocessors]
[h]
type = AverageElementSize
execute_on = FINAL
[]
[L2u]
type = ElementL2FunctorError
approximate = superficial_u
exact = exact_u
execute_on = FINAL
[]
[L2v]
type = ElementL2FunctorError
approximate = superficial_v
exact = exact_v
execute_on = FINAL
[]
[L2p]
type = ElementL2FunctorError
approximate = pressure
exact = exact_pressure
execute_on = FINAL
[]
[L2gradp]
type = ElementVectorL2Error
variable = reconstructed_grad_p
function_x = 0
function_y = 0
execute_on = FINAL
[]
[boundary_mass_balance]
type = VolumetricFlowRate
boundary = 'left right top bottom'
vel_x = superficial_u
vel_y = superficial_v
advected_quantity = density
rhie_chow_user_object = rc
execute_on = FINAL
[]
[max_pressure_error]
type = ElementExtremeFunctorValue
functor = pressure_error
value_type = max_abs
execute_on = FINAL
[]
[]
[Outputs]
exodus = false
[csv]
type = CSV
execute_on = FINAL
[]
[]
(test/tests/meshgenerators/manifold_subdomain/cone.i)
expected = '2975'
!include check.i
[Mesh]
[disk]
type = ConcentricCircleMeshGenerator
num_sectors = 6
radii = '0.9'
rings = '10'
has_outer_square = false
preserve_volumes = false
[]
[cone]
type = ParsedNodeTransformGenerator
input = disk
z_function = '0.9 - sqrt(x * x + y * y)'
[]
[surface_quads]
type = StitchMeshGenerator
inputs = 'cone disk'
stitch_boundaries_pairs = 'outer outer'
clear_stitched_boundary_ids = true
[]
[background]
type = GeneratedMeshGenerator
dim = 3
nx = 25
ny = 25
nz = 25
xmin = -1
xmax = 1
ymin = -1
ymax = 1
zmax = 1
[]
[surface]
type = ElementsToSimplicesConverter
input = surface_quads
[]
[tag]
type = ManifoldSubdomainGenerator
input = background
manifold = surface
block_id = 1
[]
[remove]
type = BlockDeletionGenerator
input = tag
block = '0'
[]
[]
(modules/navier_stokes/test/tests/finite_volume/ins/turbulence/lid-driven/segregated/lid-driven-turb-capped.i)
##########################################################
# Lid-driven cavity test
# Reynolds: 5,000
# Author: Dr. Mauricio Tano
# Last Update: November, 2023
# Turbulent model using:
# k-epsilon model with capped mixing length
# Standard wall functions
# SIMPLE Solve
##########################################################
### Thermophysical Properties ###
mu = 2e-5
rho = 1.0
### Operation Conditions ###
lid_velocity = 1.0
side_length = 0.1
### Initial Conditions ###
intensity = 0.01
k_init = '${fparse 1.5*(intensity * lid_velocity)^2}'
eps_init = '${fparse C_mu^0.75 * k_init^1.5 / side_length}'
### k-epsilon Closure Parameters ###
sigma_k = 1.0
sigma_eps = 1.3
C1_eps = 1.44
C2_eps = 1.92
C_mu = 0.09
C_pl = 0.1
### Modeling parameters ###
bulk_wall_treatment = false
walls = 'left top right bottom'
wall_treatment = 'eq_newton' # Options: eq_newton, eq_incremental, eq_linearized, neq
pressure_tag = "pressure_grad"
[GlobalParams]
rhie_chow_user_object = 'rc'
advected_interp_method = 'upwind'
velocity_interp_method = 'rc'
[]
[Mesh]
[gen]
type = GeneratedMeshGenerator
dim = 2
xmin = 0
xmax = ${side_length}
ymin = 0
ymax = ${side_length}
nx = 12
ny = 12
[]
[break_symmetries]
type = ParsedNodeTransformGenerator
input = gen
constant_names = 'side_length'
constant_expressions = '${side_length}'
x_function = 'if(x<side_length*1.001 / 2 & x > side_length * 0.999 / 2, x * 1.05, x)'
y_function = 'if(y<side_length*1.001 / 2 & y > side_length * 0.999 / 2, y * 1.05, y)'
[]
# Prevent test diffing on distributed parallel element numbering
allow_renumbering = false
[]
[Problem]
nl_sys_names = 'u_system v_system pressure_system TKE_system TKED_system'
previous_nl_solution_required = true
[]
[UserObjects]
[rc]
type = INSFVRhieChowInterpolatorSegregated
u = vel_x
v = vel_y
pressure = pressure
[]
[]
[Variables]
[vel_x]
type = INSFVVelocityVariable
solver_sys = u_system
two_term_boundary_expansion = false
[]
[vel_y]
type = INSFVVelocityVariable
solver_sys = v_system
two_term_boundary_expansion = false
[]
[pressure]
type = INSFVPressureVariable
solver_sys = pressure_system
initial_condition = 0.2
two_term_boundary_expansion = false
[]
[TKE]
type = INSFVEnergyVariable
solver_sys = TKE_system
initial_condition = ${k_init}
two_term_boundary_expansion = false
[]
[TKED]
type = INSFVEnergyVariable
solver_sys = TKED_system
initial_condition = ${eps_init}
two_term_boundary_expansion = false
[]
[]
[ICs]
[vx]
type = FunctionIC
variable = vel_x
function = 'if(y>0.09, 0.1, -0.001)'
[]
[vy]
type = FunctionIC
variable = vel_y
function = 'if(x>0.05, -0.001, 0.001)'
[]
[]
[FVKernels]
[u_advection]
type = INSFVMomentumAdvection
variable = vel_x
rho = ${rho}
momentum_component = 'x'
[]
[u_viscosity]
type = INSFVMomentumDiffusion
variable = vel_x
mu = ${mu}
momentum_component = 'x'
[]
[u_viscosity_turbulent]
type = INSFVMomentumDiffusion
variable = vel_x
mu = 'mu_t'
momentum_component = 'x'
complete_expansion = true
u = vel_x
v = vel_y
[]
[u_pressure]
type = INSFVMomentumPressure
variable = vel_x
momentum_component = 'x'
pressure = pressure
extra_vector_tags = ${pressure_tag}
[]
[v_advection]
type = INSFVMomentumAdvection
variable = vel_y
rho = ${rho}
momentum_component = 'y'
[]
[v_viscosity]
type = INSFVMomentumDiffusion
variable = vel_y
mu = ${mu}
momentum_component = 'y'
[]
[v_viscosity_turbulent]
type = INSFVMomentumDiffusion
variable = vel_y
mu = 'mu_t'
momentum_component = 'y'
complete_expansion = true
u = vel_x
v = vel_y
[]
[v_pressure]
type = INSFVMomentumPressure
variable = vel_y
momentum_component = 'y'
pressure = pressure
extra_vector_tags = ${pressure_tag}
[]
[p_diffusion]
type = FVAnisotropicDiffusion
variable = pressure
coeff = "Ainv"
coeff_interp_method = 'average'
[]
[p_source]
type = FVDivergence
variable = pressure
vector_field = "HbyA"
force_boundary_execution = true
[]
[TKE_advection]
type = INSFVTurbulentAdvection
variable = TKE
rho = ${rho}
[]
[TKE_diffusion]
type = INSFVTurbulentDiffusion
variable = TKE
coeff = ${mu}
[]
[TKE_diffusion_turbulent]
type = INSFVTurbulentDiffusion
variable = TKE
coeff = 'mu_t'
scaling_coef = ${sigma_k}
[]
[TKE_source_sink]
type = INSFVTKESourceSink
variable = TKE
u = vel_x
v = vel_y
epsilon = TKED
rho = ${rho}
mu = ${mu}
mu_t = 'mu_t'
C_pl = ${C_pl}
walls = ${walls}
wall_treatment = ${wall_treatment}
[]
[TKED_advection]
type = INSFVTurbulentAdvection
variable = TKED
rho = ${rho}
walls = ${walls}
[]
[TKED_diffusion]
type = INSFVTurbulentDiffusion
variable = TKED
coeff = ${mu}
walls = ${walls}
[]
[TKED_diffusion_turbulent]
type = INSFVTurbulentDiffusion
variable = TKED
coeff = 'mu_t'
scaling_coef = ${sigma_eps}
walls = ${walls}
[]
[TKED_source_sink]
type = INSFVTKEDSourceSink
variable = TKED
u = vel_x
v = vel_y
tke = TKE
rho = ${rho}
mu = ${mu}
mu_t = 'mu_t'
C1_eps = ${C1_eps}
C2_eps = ${C2_eps}
C_pl = ${C_pl}
walls = ${walls}
wall_treatment = ${wall_treatment}
[]
[]
[FVBCs]
[top_x]
type = INSFVNoSlipWallBC
variable = vel_x
boundary = 'top'
function = ${lid_velocity}
[]
[no_slip_x]
type = INSFVNoSlipWallBC
variable = vel_x
boundary = 'left right bottom'
function = 0
[]
[no_slip_y]
type = INSFVNoSlipWallBC
variable = vel_y
boundary = 'left right top bottom'
function = 0
[]
[walls_mu_t]
type = INSFVTurbulentViscosityWallFunction
boundary = 'left right top bottom'
variable = mu_t
u = vel_x
v = vel_y
rho = ${rho}
mu = ${mu}
mu_t = 'mu_t'
tke = TKE
wall_treatment = ${wall_treatment}
[]
[]
[AuxVariables]
[mu_t]
type = MooseVariableFVReal
initial_condition = '${fparse rho * C_mu * ${k_init}^2 / eps_init}'
two_term_boundary_expansion = false
[]
[]
[AuxKernels]
[compute_mu_t]
type = kEpsilonViscosityAux
variable = mu_t
C_mu = ${C_mu}
tke = TKE
epsilon = TKED
mu = ${mu}
rho = ${rho}
u = vel_x
v = vel_y
bulk_wall_treatment = ${bulk_wall_treatment}
walls = ${walls}
wall_treatment = ${wall_treatment}
execute_on = 'NONLINEAR'
[]
[]
[Executioner]
type = SIMPLENonlinearAssembly
rhie_chow_user_object = 'rc'
momentum_systems = 'u_system v_system'
pressure_system = 'pressure_system'
turbulence_systems = 'TKED_system TKE_system'
pressure_gradient_tag = ${pressure_tag}
momentum_equation_relaxation = 0.8
pressure_variable_relaxation = 0.5
turbulence_equation_relaxation = '0.8 0.8'
num_iterations = 500
pressure_absolute_tolerance = 1e-12
momentum_absolute_tolerance = 1e-12
turbulence_absolute_tolerance = '1e-12 1e-12'
momentum_petsc_options_iname = '-pc_type -pc_hypre_type'
momentum_petsc_options_value = 'hypre boomeramg'
pressure_petsc_options_iname = '-pc_type -pc_hypre_type'
pressure_petsc_options_value = 'hypre boomeramg'
momentum_l_abs_tol = 1e-14
pressure_l_abs_tol = 1e-14
turbulence_l_abs_tol = 1e-14
momentum_l_max_its = 30
pressure_l_max_its = 30
momentum_l_tol = 0.0
pressure_l_tol = 0.0
turbulence_l_tol = 0.0
print_fields = false
pin_pressure = true
pressure_pin_value = 0.0
pressure_pin_point = '0.01 0.099 0.0'
continue_on_max_its = true
[]
[Outputs]
csv = true
perf_graph = false
print_nonlinear_residuals = false
print_linear_residuals = true
[]
[VectorPostprocessors]
[side_bottom]
type = SideValueSampler
boundary = 'bottom'
variable = 'vel_x vel_y pressure TKE TKED'
sort_by = 'x'
execute_on = 'timestep_end'
[]
[side_top]
type = SideValueSampler
boundary = 'top'
variable = 'vel_x vel_y pressure TKE TKED'
sort_by = 'x'
execute_on = 'timestep_end'
[]
[side_left]
type = SideValueSampler
boundary = 'left'
variable = 'vel_x vel_y pressure TKE TKED'
sort_by = 'y'
execute_on = 'timestep_end'
[]
[side_right]
type = SideValueSampler
boundary = 'right'
variable = 'vel_x vel_y pressure TKE TKED'
sort_by = 'y'
execute_on = 'timestep_end'
[]
[horizontal_center]
type = LineValueSampler
start_point = '${fparse 0.01 * side_length} ${fparse 0.499 * side_length} 0'
end_point = '${fparse 0.99 * side_length} ${fparse 0.499 * side_length} 0'
num_points = ${Mesh/gen/nx}
variable = 'vel_x vel_y pressure TKE TKED'
sort_by = 'x'
execute_on = 'timestep_end'
[]
[vertical_center]
type = LineValueSampler
start_point = '${fparse 0.499 * side_length} ${fparse 0.01 * side_length} 0'
end_point = '${fparse 0.499 * side_length} ${fparse 0.99 * side_length} 0'
num_points = ${Mesh/gen/ny}
variable = 'vel_x vel_y pressure TKE TKED'
sort_by = 'y'
execute_on = 'timestep_end'
[]
[]
(test/tests/meshgenerators/xyz_delaunay_generator/xyzdelaunay_quadratic.i)
# Second-order (TET10/TET14) tetrahedralization with XYZDelaunayGenerator.
#
# The outer boundary is converted to second order and THEN deformed by a nonlinear
# transform, so its mid-edge nodes lie off the straight-edge midpoint (i.e. it carries
# genuine curvature). XYZDelaunayGenerator inherits that curvature onto the generated
# tets. A second-order hole is stitched in to exercise second-order stitching.
[Mesh]
# ---- Outer boundary: curved, second order ----
[gmg]
type = GeneratedMeshGenerator
dim = 3
nx = 2
ny = 2
nz = 2
elem_type = TET4
[]
[bdy_second]
type = ElementOrderConversionGenerator
input = gmg
conversion_type = SECOND_ORDER
[]
[outer_bdy]
type = ParsedNodeTransformGenerator
input = bdy_second
x_function = 'x'
y_function = 'y'
z_function = 'z + 0.3 * x * y * z'
[]
# ---- Hole: second order, smaller interior cube ----
[hgmg]
type = GeneratedMeshGenerator
dim = 3
nx = 1
ny = 1
nz = 1
elem_type = TET4
[]
[hole_second]
type = ElementOrderConversionGenerator
input = hgmg
conversion_type = SECOND_ORDER
[]
[hole]
type = ParsedNodeTransformGenerator
input = hole_second
x_function = '0.35 + 0.3 * x'
y_function = '0.35 + 0.3 * y'
z_function = '0.35 + 0.3 * z'
[]
# Give the stitched hole a distinct subdomain id so it differs from the
# generated tetrahedra (which are subdomain 0).
[hole_block]
type = SubdomainIDGenerator
input = hole
subdomain_id = 3
[]
[triang]
type = XYZDelaunayGenerator
boundary = 'outer_bdy'
holes = 'hole_block'
stitch_holes = 'true'
desired_volume = 100000
tet_element_type = TET10
[]
[]
[Executioner]
type = Steady
[]
[Problem]
solve = false
[]
# The element type is what these tests exist to verify, and it is reported here
# rather than inferred from node counts. Counts cannot be golded on this mesh:
# desired_volume = 100000 leaves the 2x2x2 cube essentially unrefined, so the
# point set is near-cospherical and Netgen's tie-break -- and hence the exact
# tetrahedralization -- depends on the order the boundary nodes reach it, which
# differs between replicated and distributed meshes (libMesh's Netgen interface
# serializes the input mesh before triangulating it). Element types and the
# per-subdomain volumes are invariant to that retriangulation.
[Reporters]
[mesh_info]
type = MeshInfo
items = 'subdomains'
subdomain_items = 'elem_types volume'
[]
[]
[Outputs]
file_base = 'xyzdelaunay_quadratic_tet10_out'
[json]
type = JSON
execute_system_information_on = 'NONE'
[]
[]
(test/tests/meshgenerators/xyz_delaunay_generator/err_xyzdelaunay_with_holes_mix.i)
[Mesh]
[fmg]
type = FileMeshGenerator
file = 'gold/2d_cube.e'
[]
[outer_bdy]
type = ParsedNodeTransformGenerator
input = fmg
x_function = "x"
y_function = "y"
z_function = "z+x*y*z"
[]
[hole_1_2d]
type = ParsedNodeTransformGenerator
input = fmg
x_function = ".25+.125*x"
y_function = ".25+.125*y"
z_function = ".25+.125*z"
[]
[hole_1]
type = ElementGenerator
input = 'hole_1_2d'
elem_type = TET4
nodal_positions = '0 0 0
0 1 0
1 0 0
0 0 1'
element_connectivity = '0 1 2 3'
[]
[hole_2]
type = ParsedNodeTransformGenerator
input = fmg
x_function = ".75+.125*x"
y_function = ".75+.125*y"
z_function = ".75+.125*z"
[]
[triang]
type = XYZDelaunayGenerator
boundary = 'outer_bdy'
holes = 'hole_1
hole_2'
# Let NetGen know interior points are okay
desired_volume = 100000
[]
[]
(test/tests/meshgenerators/xyz_delaunay_generator/xyzdelaunay_with_holes_1d.i)
[Mesh]
[gmg]
type = GeneratedMeshGenerator
dim = 3
nx = 1
ny = 1
nz = 1
[]
[outer_bdy]
type = ParsedNodeTransformGenerator
input = gmg
x_function = "x"
y_function = "y"
z_function = "z+x*y*z"
[]
[hole_1d]
type = ParsedCurveGenerator
x_formula = 'cos(t)'
y_formula = 'sin(t)'
section_bounding_t_values = '0.0 ${fparse 2.0*pi}'
nums_segments = '10'
constant_names = 'pi'
constant_expressions = '${fparse pi}'
is_closed_loop = true
[]
[triang]
type = XYZDelaunayGenerator
boundary = 'outer_bdy'
holes = 'hole_1d'
[]
[]
(test/tests/meshgenerators/xyz_delaunay_generator/xyzdelaunay_with_holes_2d.i)
[Mesh]
[fmg]
type = FileMeshGenerator
file = 'gold/2d_cube.e'
[]
[outer_bdy]
type = ParsedNodeTransformGenerator
input = fmg
x_function = "x"
y_function = "y"
z_function = "z+x*y*z"
[]
[hole_1]
type = ParsedNodeTransformGenerator
input = fmg
x_function = ".25+.125*x"
y_function = ".25+.125*y"
z_function = ".25+.125*z"
[]
[hole_2]
type = ParsedNodeTransformGenerator
input = fmg
x_function = ".75+.125*x"
y_function = ".75+.125*y"
z_function = ".75+.125*z"
[]
[triang]
type = XYZDelaunayGenerator
boundary = 'outer_bdy'
holes = 'hole_1
hole_2'
# Let NetGen know interior points are okay
desired_volume = 100000
[]
[]
[Executioner]
type = Steady
[]
[Postprocessors]
[volume]
type = VolumePostprocessor
[]
[]
[Problem]
solve = false
[]
[Outputs]
[output]
type = CSV
file_base = 'xyzdelaunay_with_holes_out'
[]
[]
(test/tests/meshgenerators/compute_node_position/3d.i)
[Mesh]
[gen]
type = GeneratedMeshGenerator
dim = 3
nx = 5
ny = 5
nz = 10
xmin = -0.5
ymin = -0.5
xmax = 0.5
ymax = 0.5
zmax = 3
[]
[node_pos]
type = ParsedNodeTransformGenerator
input = gen
x_function = 'x*cos(z) + y*sin(z)'
y_function = '-x*sin(z) + y*cos(z)'
z_function = 'z^0.8'
[]
[]
(test/tests/meshgenerators/xyz_delaunay_generator/xyzdelaunay_stitching.i)
[Mesh]
[gmg]
type = GeneratedMeshGenerator
dim = 3
elem_type = TET4
nx = 1
ny = 1
nz = 1
xmin = -1
xmax = 1
ymin = -1
ymax = 1
zmin = -1
zmax = 1
[]
[outer_bdy]
type = ParsedNodeTransformGenerator
input = gmg
x_function = "z+x"
y_function = "y"
z_function = "z-x"
[]
[hole_1]
type = ParsedNodeTransformGenerator
input = gmg
x_function = ".25+.125*x"
y_function = ".25+.125*y"
z_function = ".25+.125*z"
[]
[hole_1_name]
type = RenameBlockGenerator
input = hole_1
old_block = 0
new_block = hole
[]
[hole_2]
type = ParsedNodeTransformGenerator
input = gmg
x_function = ".75+.125*x"
y_function = ".75+.125*y"
z_function = ".75+.125*z"
[]
[hole_2_name_1]
type = RenameBlockGenerator
input = hole_2
old_block = 0
new_block = 1
[]
[hole_2_name_2]
type = RenameBlockGenerator
input = hole_2_name_1
old_block = 1
new_block = hole
[]
[triang]
type = XYZDelaunayGenerator
boundary = 'outer_bdy'
holes = 'hole_1_name
hole_2'
stitch_holes = 'true
false'
desired_volume = 10000
output_subdomain_name = "triangles"
[]
[]
[Executioner]
type = Steady
[]
[Postprocessors]
[volume]
type = VolumePostprocessor
[]
[]
[Problem]
solve = false
[]
[Outputs]
csv = true
[]
(test/tests/meshgenerators/xyz_delaunay_generator/xyzdelaunay_nested.i)
[Mesh]
[inner_cube]
type = GeneratedMeshGenerator
dim = 3
elem_type = TET4
nx = 1
ny = 1
nz = 1
xmin = -0.4
xmax = 0.4
ymin = -0.4
ymax = 0.4
zmin = -0.4
zmax = 0.4
[]
[gmg]
type = GeneratedMeshGenerator
dim = 3
nx = 1
ny = 1
nz = 1
xmin = -1
xmax = 1
ymin = -1
ymax = 1
zmin = -1
zmax = 1
[]
[layer_2_bdy]
type = ParsedNodeTransformGenerator
input = gmg
x_function = "z+x"
y_function = "y"
z_function = "z-x"
[]
[layer_3_bdy]
type = ParsedNodeTransformGenerator
input = gmg
x_function = "3*x"
y_function = "3*y"
z_function = "3*z"
[]
[layer_4_bdy]
type = ParsedNodeTransformGenerator
input = gmg
x_function = "4*x"
y_function = "4*y"
z_function = "4*z"
[]
[triang_2]
type = XYZDelaunayGenerator
boundary = 'layer_2_bdy'
holes = 'inner_cube'
stitch_holes = 'true'
desired_volume = 0.1
[]
[triang_3]
type = XYZDelaunayGenerator
boundary = 'layer_3_bdy'
holes = 'triang_2'
stitch_holes = 'true'
desired_volume = 0.2
[]
[triang_4]
type = XYZDelaunayGenerator
boundary = 'layer_4_bdy'
holes = 'triang_3'
stitch_holes = 'true'
desired_volume = 0.4
[]
[]
[Executioner]
type = Steady
[]
[Postprocessors]
[volume]
type = VolumePostprocessor
[]
[]
[Problem]
solve = false
[]
[Outputs]
csv = true
[]
(modules/navier_stokes/test/tests/finite_volume/ins/turbulence/lid-driven/newton_physics/lid-driven-turb-capped-physics.i)
##########################################################
# Lid-driven cavity test
# Reynolds: 5,000
# Author: Dr. Mauricio Tano
# Last Update: May, 2024
# Turbulent model using:
# k-epsilon model with capped mixing length
# Standard wall functions
# SIMPLE Solve
##########################################################
### Thermophysical Properties ###
mu = 2e-5
rho = 1.0
### Operation Conditions ###
lid_velocity = 1.0
side_length = 0.1
### k-epsilon Closure Parameters ###
sigma_k = 1.0
sigma_eps = 1.3
C1_eps = 1.44
C2_eps = 1.92
C_mu = 0.09
C_pl = 0.1
### Initial Conditions ###
intensity = 0.01
k_init = '${fparse 1.5*(intensity * lid_velocity)^2}'
eps_init = '${fparse C_mu^0.75 * k_init^1.5 / side_length}'
mu_t_init = '${fparse rho * C_mu * k_init * k_init / eps_init}'
### Modeling parameters ###
walls = 'left top right bottom'
bulk_wall_treatment = false
wall_treatment = 'eq_newton' # Options: eq_newton, eq_incremental, eq_linearized, neq
[Mesh]
[gen]
type = GeneratedMeshGenerator
dim = 2
xmin = 0
xmax = ${side_length}
ymin = 0
ymax = ${side_length}
nx = 12
ny = 12
[]
[break_symmetries]
type = ParsedNodeTransformGenerator
input = gen
constant_names = 'side_length'
constant_expressions = '${side_length}'
x_function = 'if(x<side_length*1.001 / 2 & x > side_length * 0.999 / 2, x * 1.05, x)'
y_function = 'if(y<side_length*1.001 / 2 & y > side_length * 0.999 / 2, y * 1.05, y)'
[]
# Prevent test diffing on distributed parallel element numbering
allow_renumbering = false
[]
[Physics]
[NavierStokes]
[Flow]
[flow]
compressibility = 'incompressible'
density = ${rho}
dynamic_viscosity = ${mu}
initial_pressure = 0.2
initial_velocity = 'ini_vx ini_vy 0'
wall_boundaries = 'top left right bottom'
momentum_wall_types = 'noslip noslip noslip noslip'
momentum_wall_functors = '${lid_velocity} 0; 0 0; 0 0; 0 0'
pin_pressure = true
pinned_pressure_type = point-value
pinned_pressure_value = 0
pinned_pressure_point = '0.01 0.099 0.0'
momentum_two_term_bc_expansion = false
pressure_two_term_bc_expansion = false
[]
[]
[Turbulence]
[keps]
turbulence_handling = 'k-epsilon'
tke_name = TKE
tked_name = TKED
# Initialization
initial_tke = ${k_init}
initial_tked = ${eps_init}
initial_mu_t = ${mu_t_init}
# Model parameters
C1_eps = ${C1_eps}
C2_eps = ${C2_eps}
C_mu = ${C_mu}
C_pl = ${C_pl}
sigma_k = ${sigma_k}
sigma_eps = ${sigma_eps}
# Wall parameters
turbulence_walls = ${walls}
bulk_wall_treatment = ${bulk_wall_treatment}
wall_treatment_eps = ${wall_treatment}
# Numerical parameters
turbulent_viscosity_two_term_bc_expansion = false
mu_t_as_aux_variable = true
tke_two_term_bc_expansion = false
tked_two_term_bc_expansion = false
[]
[]
[]
[]
[Functions]
[ini_vx]
type = ParsedFunction
expression = 'if(y>0.09, 0.1, -0.0001)'
[]
[ini_vy]
type = ParsedFunction
expression = 'if(x>0.05, -0.001, 0.001)'
[]
[]
[AuxVariables]
[dummy]
type = MooseVariableConstMonomial
[]
[]
[Bounds]
[min_tke]
type = ConstantBounds
variable = dummy
bound_value = 1e-8
bounded_variable = TKE
bound_type = lower
[]
[min_eps]
type = ConstantBounds
variable = dummy
bound_value = 1e-8
bounded_variable = TKED
bound_type = lower
[]
[]
[Executioner]
type = Steady
solve_type = 'NEWTON'
petsc_options_iname = '-pc_type -pc_factor_shift_type -snes_type'
petsc_options_value = 'lu NONZERO vinewtonrsls '
nl_abs_tol = 1e-7
nl_rel_tol = 1e-8
nl_max_its = 100
line_search = none
automatic_scaling = true
[]
[Outputs]
csv = true
perf_graph = false
print_nonlinear_residuals = true
print_linear_residuals = false
[]
[VectorPostprocessors]
[side_bottom]
type = SideValueSampler
boundary = 'bottom'
variable = 'vel_x vel_y pressure TKE TKED'
sort_by = 'x'
execute_on = 'timestep_end'
[]
[side_top]
type = SideValueSampler
boundary = 'top'
variable = 'vel_x vel_y pressure TKE TKED'
sort_by = 'x'
execute_on = 'timestep_end'
[]
[side_left]
type = SideValueSampler
boundary = 'left'
variable = 'vel_x vel_y pressure TKE TKED'
sort_by = 'y'
execute_on = 'timestep_end'
[]
[side_right]
type = SideValueSampler
boundary = 'right'
variable = 'vel_x vel_y pressure TKE TKED'
sort_by = 'y'
execute_on = 'timestep_end'
[]
[horizontal_center]
type = LineValueSampler
start_point = '${fparse 0.01 * side_length} ${fparse 0.499 * side_length} 0'
end_point = '${fparse 0.99 * side_length} ${fparse 0.499 * side_length} 0'
num_points = ${Mesh/gen/nx}
variable = 'vel_x vel_y pressure TKE TKED'
sort_by = 'x'
execute_on = 'timestep_end'
[]
[vertical_center]
type = LineValueSampler
start_point = '${fparse 0.499 * side_length} ${fparse 0.01 * side_length} 0'
end_point = '${fparse 0.499 * side_length} ${fparse 0.99 * side_length} 0'
num_points = ${Mesh/gen/ny}
variable = 'vel_x vel_y pressure TKE TKED'
sort_by = 'y'
execute_on = 'timestep_end'
[]
[]
(modules/contact/test/tests/dual_mortar/mortar_mechanical_contact_force_balance.i)
# Newton's third law check for mortar mechanical contact across a curved interface.
#
# The stress-divergence residual is stored in a dedicated vector tag. At a converged
# unconstrained contact node, its value is opposite the mortar contact force, so the
# tagged residual sums on the two contact boundaries must cancel.
!include dm_mechanical_contact.i
# Curve the interface while preserving the gap between the two surfaces.
curvature = 0.4
[Mesh]
[left_curve]
type = ParsedNodeTransformGenerator
input = left_block_id
x_function = 'x + ${curvature} * y * y'
[]
[right_curve]
type = ParsedNodeTransformGenerator
input = right_block_id
x_function = 'x + ${curvature} * y * y'
[]
[combined_mesh]
inputs := 'left_curve right_curve'
[]
[]
[Functions]
# Keep the curved interface in contact at every output step.
[horizontal_movement]
y := '0.06 0.1 0.1'
[]
[]
[Problem]
extra_tag_vectors = 'internal_force'
[]
[AuxVariables]
[internal_force_x]
block = '1 2'
[]
[internal_force_y]
block = '1 2'
[]
[]
[Physics/SolidMechanics/QuasiStatic]
[all]
extra_vector_tags = 'internal_force'
[]
[]
[AuxKernels]
[internal_force_x]
type = TagVectorAux
variable = internal_force_x
v = disp_x
block = '1 2'
vector_tag = internal_force
[]
[internal_force_y]
type = TagVectorAux
variable = internal_force_y
v = disp_y
block = '1 2'
vector_tag = internal_force
[]
[]
[Postprocessors]
# The parent postprocessors require a Lagrange multiplier, which the penalty case
# does not create.
active = 'secondary_force_x secondary_force_y primary_force_x primary_force_y '
'force_balance_x force_balance_y'
[secondary_force_x]
type = NodalSum
variable = internal_force_x
boundary = 11
[]
[secondary_force_y]
type = NodalSum
variable = internal_force_y
boundary = 11
[]
[primary_force_x]
type = NodalSum
variable = internal_force_x
boundary = 23
[]
[primary_force_y]
type = NodalSum
variable = internal_force_y
boundary = 23
[]
# Normalize the imbalance by the force transmitted through the secondary side.
[force_balance_x]
type = ParsedPostprocessor
expression = '(sec_x + pri_x) / sqrt(sec_x^2 + sec_y^2)'
pp_names = 'secondary_force_x secondary_force_y primary_force_x primary_force_y'
pp_symbols = 'sec_x sec_y pri_x pri_y'
[]
[force_balance_y]
type = ParsedPostprocessor
expression = '(sec_y + pri_y) / sqrt(sec_x^2 + sec_y^2)'
pp_names = 'secondary_force_x secondary_force_y primary_force_x primary_force_y'
pp_symbols = 'sec_x sec_y pri_x pri_y'
[]
[]
[Executioner]
# Resolve the force imbalance well below the test tolerance.
nl_rel_tol := 1e-12
nl_abs_tol = 1e-8
nl_max_its := 30
[]
[Outputs]
file_base := mortar_mechanical_contact_force_balance
[comp]
show := 'force_balance_x force_balance_y'
execute_on := 'TIMESTEP_END'
[]
[]
(test/tests/meshgenerators/compute_node_position/2d.i)
[Mesh]
[gen]
type = GeneratedMeshGenerator
dim = 2
nx = 11
ny = 11
xmin = -1
ymin = -2
xmax = 9
ymax = 8
[]
[node_pos]
type = ParsedNodeTransformGenerator
input = gen
x_function = 'if(x < 1 | y < 2, x, x + (y-2)*0.2)'
y_function = 'if(x < 2 | y < 1, y, y + (y-1)*(x-2) * 0.1)'
[]
[]
(test/tests/meshgenerators/advanced_extruder_generator/extrude_along_normals.i)
[Mesh]
# A flat 2D quad mesh ...
[gmg]
type = GeneratedMeshGenerator
dim = 2
nx = 4
ny = 4
xmin = -1
xmax = 1
ymin = -1
ymax = 1
[]
# ... warped into a curved 3D surface (a gentle dome), so that the surface
# normal varies from node to node
[dome]
type = ParsedNodeTransformGenerator
input = gmg
z_function = '0.5 * (1 - 0.25 * (x * x + y * y))'
[]
# Grow boundary layers off the surface by extruding each node along the
# averaged normal of the elements it is connected to
[extrude]
type = AdvancedExtruderGenerator
input = dome
extrude_along_node_normals = true
heights = '0.3'
num_layers = '3'
biases = '1.5'
[]
[]
(modules/navier_stokes/test/tests/finite_volume/pins/mms/linear-segregated/smooth-properties/smooth-properties.i)
# Manufactured solution with continuously varying density and viscosity, optionally crossed by a
# pressure baffle with a porosity jump. In coordinates normal (xn) and tangent (xt) to the line
# x - skew * y = 0.5:
# - rho = 1 + xn/2 + xt/4 + xn xt/5 and mu = mu0 (m0 + 4 xn^2)(1 + xt^2) are smooth. With m0 = 0.05
# the viscosity varies by a factor of 40 across the domain and by a factor of several between
# neighboring cells on the coarse meshes.
# - rho U = curl(psi), psi = xt/2 + xt^2/10 + eps (xn (xt/10 - 3/10) + xn^2/5), so the mass flux is
# divergence-free. U.n is continuous across xn = 0 and U_t jumps with eps, while the interstitial
# tangential velocity U_t / eps is continuous.
# - The pressure is smooth on each side. With a baffle, the right side adds the
# BernoulliFormLossPressureJump evaluated with the interface density and normal velocity.
# The forcing contains the porous advection div(rho U U / eps), the full stress
# div(mu (grad U + grad U^T - 2/3 div U I)) of superficial velocity, eps grad p, and a reaction k U.
# Without a baffle (baffle = 0), eps_left = eps_right must hold.
# The expressions were generated with sympy.
eps_left = 1
eps_right = 1
form_loss = 0
mu0 = 0.01
m0 = 0.05
reaction = 1
skew = 0
nx = 8
ny = 8
# Set baffle = 1 together with UserObjects/rc/pressure_jump_models=pressure_jump to make the
# interface a pressure baffle; otherwise it is an ordinary internal face.
baffle = 0
deviatoric = true
# Porosity of the side whose interstitial velocity is the form-loss reference: the lower one, the
# BernoulliFormLossPressureJump default.
eps_ref = '${fparse min(eps_left, eps_right)}'
[Problem]
linear_sys_names = 'u_system v_system pressure_system'
previous_nl_solution_required = true
[]
[Mesh]
[generated]
type = GeneratedMeshGenerator
dim = 2
nx = ${nx}
ny = ${ny}
[]
[right]
type = ParsedSubdomainMeshGenerator
input = generated
combinatorial_geometry = 'x > 0.5'
block_id = 2
block_name = right
[]
[left]
type = ParsedSubdomainMeshGenerator
input = right
combinatorial_geometry = 'x < 0.5'
block_id = 1
block_name = left
[]
[skew]
type = ParsedNodeTransformGenerator
input = left
x_function = 'x + ${skew} * y'
[]
[baffle]
type = SideSetsBetweenSubdomainsGenerator
input = skew
primary_block = left
paired_block = right
new_boundary = baffle
[]
[]
[FVGradientMethods]
[jump_aware]
type = FVPressureJumpGreenGaussGradient
[]
[velocity_jump_aware]
type = FVVelocityJumpGreenGaussGradient
[]
# The reconstructed pressure gradient keeps the cell pressure gradient consistent with the face
# fluxes and suppresses odd-even pressure modes.
[reconstructed]
type = FVReconstructedPressureGradient
base_gradient_method = jump_aware
gradient_relaxation = 1
[]
[]
[FVInterpolationMethods]
[average]
type = FVGeometricAverage
[]
[]
[UserObjects]
[pressure_jump]
type = BernoulliFormLossPressureJump
boundary = baffle
porosity = porosity
density = density
form_loss = ${form_loss}
[]
[rc]
type = PorousRhieChowMassFlux
u = superficial_u
v = superficial_v
pressure = pressure
rho = density
porosity = porosity
p_diffusion_kernel = p_diffusion
pressure_projection_method = consistent
[]
[]
[Variables]
[superficial_u]
type = MooseLinearVariableFVReal
solver_sys = u_system
initial_condition = 0
gradient_method = velocity_jump_aware
[]
[superficial_v]
type = MooseLinearVariableFVReal
solver_sys = v_system
initial_condition = 0
gradient_method = velocity_jump_aware
[]
[pressure]
type = MooseLinearVariableFVReal
solver_sys = pressure_system
initial_condition = 0
gradient_method = jump_aware
[]
[]
[LinearFVKernels]
[u_advection_stress]
type = LinearPWCNSFVMomentumFlux
variable = superficial_u
advected_interp_method_name = average
mu = viscosity
u = superficial_u
v = superficial_v
momentum_component = x
rhie_chow_user_object = rc
use_nonorthogonal_correction = true
use_deviatoric_terms = ${deviatoric}
[]
[v_advection_stress]
type = LinearPWCNSFVMomentumFlux
variable = superficial_v
advected_interp_method_name = average
mu = viscosity
u = superficial_u
v = superficial_v
momentum_component = y
rhie_chow_user_object = rc
use_nonorthogonal_correction = true
use_deviatoric_terms = ${deviatoric}
[]
[u_pressure]
type = LinearPWCNSFVMomentumPressure
variable = superficial_u
pressure = pressure
porosity = porosity
momentum_component = x
gradient_method = reconstructed
[]
[v_pressure]
type = LinearPWCNSFVMomentumPressure
variable = superficial_v
pressure = pressure
porosity = porosity
momentum_component = y
gradient_method = reconstructed
[]
[u_source]
type = LinearFVSource
variable = superficial_u
source_density = forcing_u
[]
[v_source]
type = LinearFVSource
variable = superficial_v
source_density = forcing_v
[]
[u_reaction]
type = LinearFVReaction
variable = superficial_u
coeff = ${reaction}
[]
[v_reaction]
type = LinearFVReaction
variable = superficial_v
coeff = ${reaction}
[]
[p_diffusion]
type = LinearFVPressureCorrectionDiffusionJump
variable = pressure
rhie_chow_user_object = rc
use_nonorthogonal_correction = true
[]
[HbyA_divergence]
type = LinearFVDivergence
variable = pressure
face_flux = HbyA
force_boundary_execution = true
[]
[]
[LinearFVBCs]
[velocity_x]
type = LinearFVAdvectionDiffusionFunctorDirichletBC
boundary = 'left right top bottom'
variable = superficial_u
functor = exact_u
[]
[velocity_y]
type = LinearFVAdvectionDiffusionFunctorDirichletBC
boundary = 'left right top bottom'
variable = superficial_v
functor = exact_v
[]
[pressure_flux]
type = LinearFVPressureFluxBC
boundary = 'left right top bottom'
variable = pressure
HbyA_flux = HbyA
Ainv = Ainv
rho = density
u = superficial_u
v = superficial_v
# The two-term boundary pressure expansion is inaccurate on this nonorthogonal mesh.
use_two_term_expansion = false
[]
[]
[FunctorMaterials]
[density]
type = ParsedFunctorMaterial
property_name = density
functor_names = 'xn xt'
expression = '1+xn/2+xt/4+xn*xt/5'
[]
[viscosity]
type = ParsedFunctorMaterial
property_name = viscosity
functor_names = 'xn xt'
expression = '${mu0}*(${m0}+4*xn^2)*(1+xt^2)'
[]
[porosity]
type = ParsedFunctorMaterial
property_name = porosity
functor_names = 'exact_porosity'
expression = 'exact_porosity'
[]
[pressure_error]
type = ParsedFunctorMaterial
property_name = pressure_error
functor_names = 'pressure exact_pressure'
expression = 'pressure-exact_pressure'
[]
[u_error]
type = ParsedFunctorMaterial
property_name = u_error
functor_names = 'superficial_u exact_u'
expression = 'superficial_u-exact_u'
[]
[v_error]
type = ParsedFunctorMaterial
property_name = v_error
functor_names = 'superficial_v exact_v'
expression = 'superficial_v-exact_v'
[]
[]
[Functions]
[xn]
type = ParsedFunction
expression = '(x-${skew}*y-0.5)/sqrt(1+${skew}^2)'
[]
[xt]
type = ParsedFunction
expression = '(${skew}*x+y)/sqrt(1+${skew}^2)'
[]
# Side indicator: 1 on the right of the interface when it is a baffle, otherwise 0.
[rs]
type = ParsedFunction
expression = 'if(x-${skew}*y>0.5,${baffle},0)'
[]
[exact_porosity]
type = ParsedFunction
expression = 'if(x-${skew}*y<0.5,${eps_left},${eps_right})'
[]
[exact_normal_velocity]
type = ParsedFunction
symbol_names = 'xn xt eps'
symbol_values = 'xn xt exact_porosity'
expression = '2*(eps*xn + 2*xt + 5)/(4*xn*xt + 10*xn + 5*xt + 20)'
[]
[exact_tangential_velocity]
type = ParsedFunction
symbol_names = 'xn xt eps'
symbol_values = 'xn xt exact_porosity'
expression = '2*eps*(-4*xn - xt + 3)/(4*xn*xt + 10*xn + 5*xt + 20)'
[]
[exact_pressure]
type = ParsedFunction
symbol_names = 'xn xt rs el er eref K'
symbol_values = 'xn xt rs ${eps_left} ${eps_right} ${eps_ref} ${form_loss}'
expression = '(el^2*er^2*eref^2*(xt + 4)*((4*xn + 1)^2 + 2*(4*xn + 1)*(2*xt - 1) + 4*(2*xt - 1)^2)/160 - '
'rs*(2*xt + 5)^2*(K*el^2*er^2 + eref^2*(el^2 - er^2))/50)/(el^2*er^2*eref^2*(xt + 4))'
[]
[forcing_normal]
type = ParsedFunction
symbol_names = 'xn xt eps mu0 m0 k'
symbol_values = 'xn xt exact_porosity ${mu0} ${m0} ${reaction}'
expression = '(3*eps^2*(2*xn + xt)*(4*xn*xt + 10*xn + 5*xt + 20)^3 + 60*eps*k*(eps*xn + 2*xt + '
'5)*(4*xn*xt + 10*xn + 5*xt + 20)^2 + 320*eps*mu0*xn*(xt^2 + 1)*(eps*(4*xn + 5)*(4*xn + xt '
'- 3) - 2*(2*xt + 5)*(eps*xn + 2*xt + 5))*(4*xn*xt + 10*xn + 5*xt + 20) + 40*eps*mu0*(m0 + '
'4*xn^2)*(xt^2 + 1)*(2*eps*(16*xn - 1)*(4*xn*xt + 10*xn + 5*xt + 20) - 3*(4*xn + '
'5)*(-2*eps*(2*xt + 5)*(4*xn + xt - 3) + (4*xn + 5)*(eps*xn + 2*xt + 5)) + 12*(2*xt + '
'5)*(eps*(4*xn*xt + 10*xn + 5*xt + 20) - 2*(2*xt + 5)*(eps*xn + 2*xt + 5)) + 4*(2*xt + '
'5)*(-eps*(4*xn + 5)*(4*xn + xt - 3) + 2*(2*xt + 5)*(eps*xn + 2*xt + 5)) - 3*(4*xn*xt + '
'10*xn + 5*xt + 20)*(2*eps*(4*xn + 5) + eps*(2*xt + 5) + 2*eps*(4*xn + xt - 3) - 8*xn - '
'10)) - 120*eps*mu0*(8*xn*(xt^2 + 1)*(eps*(4*xn*xt + 10*xn + 5*xt + 20) - 2*(2*xt + '
'5)*(eps*xn + 2*xt + 5)) + xt*(m0 + 4*xn^2)*(2*eps*(2*xt + 5)*(4*xn + xt - 3) + 2*(1 - '
'2*eps)*(4*xn*xt + 10*xn + 5*xt + 20) - (4*xn + 5)*(eps*xn + 2*xt + 5)))*(4*xn*xt + 10*xn + '
'5*xt + 20) + 6*(eps*(eps*xn - 8*xn + 11)*(4*xn*xt + 10*xn + 5*xt + 20) + (eps*(4*xn + '
'5)*(4*xn + xt - 3) - 2*(2*xt + 5)*(eps*xn + 2*xt + 5))*(eps*xn + 2*xt + 5))*(4*xn*xt + '
'10*xn + 5*xt + 20))/(30*eps*(4*xn*xt + 10*xn + 5*xt + 20)^3)'
[]
[forcing_tangential]
type = ParsedFunction
symbol_names = 'xn xt eps rs el er eref K mu0 m0 k'
symbol_values = 'xn xt exact_porosity rs ${eps_left} ${eps_right} ${eps_ref} ${form_loss} ${mu0} ${m0} ${reaction}'
expression = '(-1200*el^2*eps*er^2*eref^2*k*(xt + 4)^2*(4*xn + xt - 3)*(4*xn*xt + 10*xn + 5*xt + 20)^2 + '
'1600*el^2*er^2*eref^2*mu0*xt*(m0 + 4*xn^2)*(xt + 4)^2*(eps*(4*xn + 5)*(4*xn + xt - 3) - '
'2*(2*xt + 5)*(eps*xn + 2*xt + 5))*(4*xn*xt + 10*xn + 5*xt + 20) + '
'400*el^2*er^2*eref^2*mu0*(m0 + 4*xn^2)*(xt + 4)^2*(xt^2 + 1)*(12*eps*(4*xn + 5)*(-4*xn*xt '
'- 10*xn - 5*xt + (4*xn + 5)*(4*xn + xt - 3) - 20) - 4*(4*xn + 5)*(eps*(4*xn + 5)*(4*xn + '
'xt - 3) - 2*(2*xt + 5)*(eps*xn + 2*xt + 5)) + 12*(2*xt + 5)*(2*eps*(2*xt + 5)*(4*xn + xt - '
'3) - (4*xn + 5)*(eps*xn + 2*xt + 5)) - 2*(4*eps*xn - eps*(4*xn + 5) + 16*xt + 40)*(4*xn*xt '
'+ 10*xn + 5*xt + 20) + 3*(4*xn*xt + 10*xn + 5*xt + 20)*(4*eps*xn + eps*(4*xn + 5) - '
'16*eps*(2*xt + 5) + 16*xt + 40)) - 4800*el^2*er^2*eref^2*mu0*(xt + 4)^2*(eps*xt*(m0 + '
'4*xn^2)*(-4*xn*xt - 10*xn - 5*xt + (4*xn + 5)*(4*xn + xt - 3) - 20) + 2*xn*(xt^2 + '
'1)*(2*eps*(2*xt + 5)*(4*xn + xt - 3) + 2*(1 - 2*eps)*(4*xn*xt + 10*xn + 5*xt + 20) - (4*xn '
'+ 5)*(eps*xn + 2*xt + 5)))*(4*xn*xt + 10*xn + 5*xt + 20) + 120*el^2*er^2*eref^2*(xt + '
'4)^2*(-(eps*(4*xn + 5)*(4*xn + xt - 3) - 2*(2*xt + 5)*(eps*xn + 2*xt + 5))*(4*xn + xt - 3) '
'+ (-4*eps*xn + eps*(4*xn + xt - 3) - 8*xt - 20)*(4*xn*xt + 10*xn + 5*xt + 20))*(4*xn*xt + '
'10*xn + 5*xt + 20) - 3*eps*(5*el^2*er^2*eref^2*(xt + 4)^2*(-4*xn - 8*xt + 3) + 4*rs*(2*xt '
'+ 5)*(4*K*el^2*er^2*(xt + 4) - K*el^2*er^2*(2*xt + 5) + eref^2*(-el^2 + er^2)*(2*xt + 5) + '
'4*eref^2*(el^2 - er^2)*(xt + 4)))*(4*xn*xt + 10*xn + 5*xt + '
'20)^3)/(600*el^2*er^2*eref^2*(xt + 4)^2*(4*xn*xt + 10*xn + 5*xt + 20)^3)'
[]
[exact_u]
type = ParsedFunction
expression = '(un+${skew}*ut)/sqrt(1+${skew}^2)'
symbol_names = 'un ut'
symbol_values = 'exact_normal_velocity exact_tangential_velocity'
[]
[exact_v]
type = ParsedFunction
expression = '(-${skew}*un+ut)/sqrt(1+${skew}^2)'
symbol_names = 'un ut'
symbol_values = 'exact_normal_velocity exact_tangential_velocity'
[]
[forcing_u]
type = ParsedFunction
expression = '(fn+${skew}*ft)/sqrt(1+${skew}^2)'
symbol_names = 'fn ft'
symbol_values = 'forcing_normal forcing_tangential'
[]
[forcing_v]
type = ParsedFunction
expression = '(-${skew}*fn+ft)/sqrt(1+${skew}^2)'
symbol_names = 'fn ft'
symbol_values = 'forcing_normal forcing_tangential'
[]
[]
[Executioner]
type = SIMPLE
momentum_l_abs_tol = 1e-12
pressure_l_abs_tol = 1e-12
momentum_l_tol = 0
pressure_l_tol = 0
momentum_l_max_its = 100
pressure_l_max_its = 100
rhie_chow_user_object = rc
momentum_systems = 'u_system v_system'
pressure_system = pressure_system
momentum_equation_relaxation = 0.5
pressure_variable_relaxation = 0.2
num_iterations = 3000
pressure_absolute_tolerance = 1e-9
momentum_absolute_tolerance = 1e-9
momentum_petsc_options_iname = '-pc_type -pc_hypre_type'
momentum_petsc_options_value = 'hypre boomeramg'
pressure_petsc_options_iname = '-pc_type -pc_hypre_type'
pressure_petsc_options_value = 'hypre boomeramg'
print_fields = false
# The exact pressure is zero at (xn, xt) = (-1/4, 1/2), on the left side.
pin_pressure = true
pressure_pin_value = 0
pressure_pin_point = '${fparse 0.5 + (-0.25 + skew * (0.5 - 0.5 * skew / sqrt(1 + skew^2))) / sqrt(1 + skew^2)} '
'${fparse (0.25 * skew + 0.5 - 0.5 * skew / sqrt(1 + skew^2)) / sqrt(1 + skew^2)} 0'
[]
[Outputs]
[csv]
type = CSV
execute_on = FINAL
[]
[]
[Postprocessors]
[h]
type = AverageElementSize
execute_on = FINAL
[]
[L2u]
type = ElementL2FunctorError
approximate = superficial_u
exact = exact_u
execute_on = FINAL
[]
[L2v]
type = ElementL2FunctorError
approximate = superficial_v
exact = exact_v
execute_on = FINAL
[]
[L2p]
type = ElementL2FunctorError
approximate = pressure
exact = exact_pressure
execute_on = FINAL
[]
# The maximum pointwise errors detect cell-to-cell oscillations that the L2 norms average out.
[max_u_error]
type = ElementExtremeFunctorValue
functor = u_error
value_type = max_abs
execute_on = FINAL
[]
[max_v_error]
type = ElementExtremeFunctorValue
functor = v_error
value_type = max_abs
execute_on = FINAL
[]
[max_p_error]
type = ElementExtremeFunctorValue
functor = pressure_error
value_type = max_abs
execute_on = FINAL
[]
[]
(test/tests/meshgenerators/xyz_delaunay_generator/xyzdelaunay_smoothed.i)
[Mesh]
[inner_cube]
type = GeneratedMeshGenerator
dim = 3
elem_type = TET4
nx = 1
ny = 1
nz = 1
xmin = -0.4
xmax = 0.4
ymin = -0.4
ymax = 0.4
zmin = -0.4
zmax = 0.4
[]
[gmg]
type = GeneratedMeshGenerator
dim = 3
nx = 1
ny = 1
nz = 1
xmin = -1
xmax = 1
ymin = -1
ymax = 1
zmin = -1
zmax = 1
[]
[layer_2_bdy]
type = ParsedNodeTransformGenerator
input = gmg
x_function = "z+x"
y_function = "y"
z_function = "z-x"
[]
[layer_3_bdy]
type = ParsedNodeTransformGenerator
input = gmg
x_function = "3*x"
y_function = "3*y"
z_function = "3*z"
[]
[layer_4_bdy]
type = ParsedNodeTransformGenerator
input = gmg
x_function = "4*x"
y_function = "4*y"
z_function = "4*z"
[]
[triang_2]
type = XYZDelaunayGenerator
boundary = 'layer_2_bdy'
holes = 'inner_cube'
stitch_holes = 'true'
desired_volume = 0.1
smooth_triangulation = true
[]
[triang_3]
type = XYZDelaunayGenerator
boundary = 'layer_3_bdy'
holes = 'triang_2'
stitch_holes = 'true'
desired_volume = 0.2
smooth_triangulation = true
[]
[triang_4]
type = XYZDelaunayGenerator
boundary = 'layer_4_bdy'
holes = 'triang_3'
stitch_holes = 'true'
desired_volume = 0.4
smooth_triangulation = true
[]
[]
[Executioner]
type = Steady
[]
[Postprocessors]
[volume]
type = VolumePostprocessor
[]
[]
[Problem]
solve = false
[]
[Outputs]
csv = true
[]
(test/tests/meshgenerators/advanced_extruder_generator/extrude_along_normals_1d.i)
[Mesh]
# A straight 1D mesh ...
[gmg]
type = GeneratedMeshGenerator
dim = 1
nx = 6
xmin = -1
xmax = 1
[]
# ... bent into an arc in the x-y plane, so that the curve normal varies
# from node to node
[arc]
type = ParsedNodeTransformGenerator
input = gmg
y_function = '0.5 * (1 - x * x)'
[]
# Grow boundary layers off the curve by extruding each node along the
# averaged normal of the elements it is connected to
[extrude]
type = AdvancedExtruderGenerator
input = arc
extrude_along_node_normals = true
heights = '0.3'
num_layers = '3'
biases = '1.5'
[]
[]
(test/tests/meshgenerators/xyz_delaunay_generator/xyzdelaunay_with_holes_3d.i)
[Mesh]
[gmg]
type = GeneratedMeshGenerator
dim = 3
nx = 1
ny = 1
nz = 1
[]
[outer_bdy]
type = ParsedNodeTransformGenerator
input = gmg
x_function = "x"
y_function = "y"
z_function = "z+x*y*z"
[]
[hole_1]
type = ParsedNodeTransformGenerator
input = gmg
x_function = ".25+.125*x"
y_function = ".25+.125*y"
z_function = ".25+.125*z"
[]
[hole_2]
type = ParsedNodeTransformGenerator
input = gmg
x_function = ".75+.125*x"
y_function = ".75+.125*y"
z_function = ".75+.125*z"
[]
[triang]
type = XYZDelaunayGenerator
boundary = 'outer_bdy'
holes = 'hole_1
hole_2'
# Let NetGen know interior points are okay
desired_volume = 100000
[]
[]
[Executioner]
type = Steady
[]
[Postprocessors]
[volume]
type = VolumePostprocessor
[]
[]
[Problem]
solve = false
[]
[Outputs]
[output]
type = CSV
file_base = 'xyzdelaunay_with_holes_out'
[]
[]
(modules/navier_stokes/test/tests/finite_volume/pins/mms/linear-segregated/hydrostatic-jump/hydrostatic-jump.i)
# Fluid at rest under gravity in a closed box split by a pressure baffle across which porosity
# jumps. The interface x - skew * y = interface is a mesh line.
# The superficial momentum balance at rest is 0 = -eps grad(p) + eps rho g, so
# U = 0 and grad(p) = rho g on both sides,
# independent of porosity. With density rho = rho_0 + strat * z linear in the height
# z = -g . x / |g|, the exact pressure is
# p = -|g| (rho_0 z + strat z^2 / 2) + const.
# The body force is the porosity-weighted buoyancy eps rho g, applied either by
# LinearFVMomentumBuoyancy or, with LinearFVKernels/inactive = 'u_buoyancy v_buoyancy', by
# LinearFVMomentumBoussinesq with a temperature chosen so that -alpha rho_ref (T - T_ref) = rho.
rho_0 = 1
strat = -0.1
eps_left = 1
eps_right = 1
mu = 0.01
reaction = 1
gx = 0
gy = -9.81
interface = 0.5
skew = 0
nx = 8
ny = 8
nonorthogonal = false
alpha = 1e-3
T_ref = 300
pressure_gradient_method = reconstructed
[Problem]
linear_sys_names = 'u_system v_system pressure_system'
previous_nl_solution_required = true
[]
[Mesh]
[generated]
type = GeneratedMeshGenerator
dim = 2
nx = ${nx}
ny = ${ny}
[]
[right]
type = ParsedSubdomainMeshGenerator
input = generated
combinatorial_geometry = 'x > ${interface}'
block_id = 2
block_name = right
[]
[left]
type = ParsedSubdomainMeshGenerator
input = right
combinatorial_geometry = 'x < ${interface}'
block_id = 1
block_name = left
[]
[skew]
type = ParsedNodeTransformGenerator
input = left
x_function = 'x + ${skew} * y'
[]
[baffle]
type = SideSetsBetweenSubdomainsGenerator
input = skew
primary_block = left
paired_block = right
new_boundary = baffle
[]
[]
[FVGradientMethods]
[jump_aware]
type = FVPressureJumpGreenGaussGradient
[]
[velocity_jump_aware]
type = FVVelocityJumpGreenGaussGradient
[]
[reconstructed]
type = FVReconstructedPressureGradient
base_gradient_method = jump_aware
gradient_relaxation = 1
[]
[]
[FVInterpolationMethods]
[average]
type = FVGeometricAverage
[]
[]
[UserObjects]
[pressure_jump]
type = BernoulliFormLossPressureJump
boundary = baffle
porosity = porosity
density = density
[]
[rc]
type = PorousRhieChowMassFlux
u = superficial_u
v = superficial_v
pressure = pressure
rho = density
porosity = porosity
p_diffusion_kernel = p_diffusion
pressure_jump_models = pressure_jump
pressure_projection_method = consistent
# The body force enters H/A through face averages, so the 1/A diffusion must be averaged the
# same way for the hydrostatic balance to hold on the face when the viscous A varies.
pressure_diffusion_interpolation = average
[]
[]
[Variables]
[superficial_u]
type = MooseLinearVariableFVReal
solver_sys = u_system
initial_condition = 0
gradient_method = velocity_jump_aware
[]
[superficial_v]
type = MooseLinearVariableFVReal
solver_sys = v_system
initial_condition = 0
gradient_method = velocity_jump_aware
[]
[pressure]
type = MooseLinearVariableFVReal
solver_sys = pressure_system
initial_condition = 0
gradient_method = jump_aware
[]
[]
[LinearFVKernels]
inactive = 'u_boussinesq v_boussinesq'
[u_advection]
type = LinearPWCNSFVMomentumFlux
variable = superficial_u
advected_interp_method_name = average
mu = ${mu}
u = superficial_u
v = superficial_v
momentum_component = x
rhie_chow_user_object = rc
use_nonorthogonal_correction = ${nonorthogonal}
[]
[v_advection]
type = LinearPWCNSFVMomentumFlux
variable = superficial_v
advected_interp_method_name = average
mu = ${mu}
u = superficial_u
v = superficial_v
momentum_component = y
rhie_chow_user_object = rc
use_nonorthogonal_correction = ${nonorthogonal}
[]
[u_pressure]
type = LinearPWCNSFVMomentumPressure
variable = superficial_u
pressure = pressure
porosity = porosity
momentum_component = x
gradient_method = ${pressure_gradient_method}
[]
[v_pressure]
type = LinearPWCNSFVMomentumPressure
variable = superficial_v
pressure = pressure
porosity = porosity
momentum_component = y
gradient_method = ${pressure_gradient_method}
[]
[u_buoyancy]
type = LinearFVMomentumBuoyancy
variable = superficial_u
rho = density
porosity = porosity
reference_rho = 0
gravity = '${gx} ${gy} 0'
momentum_component = x
[]
[v_buoyancy]
type = LinearFVMomentumBuoyancy
variable = superficial_v
rho = density
porosity = porosity
reference_rho = 0
gravity = '${gx} ${gy} 0'
momentum_component = y
[]
[u_boussinesq]
type = LinearFVMomentumBoussinesq
variable = superficial_u
T_fluid = T_fluid
rho = 1
alpha_name = ${alpha}
ref_temperature = ${T_ref}
porosity = porosity
gravity = '${gx} ${gy} 0'
momentum_component = x
[]
[v_boussinesq]
type = LinearFVMomentumBoussinesq
variable = superficial_v
T_fluid = T_fluid
rho = 1
alpha_name = ${alpha}
ref_temperature = ${T_ref}
porosity = porosity
gravity = '${gx} ${gy} 0'
momentum_component = y
[]
[u_reaction]
type = LinearFVReaction
variable = superficial_u
coeff = ${reaction}
[]
[v_reaction]
type = LinearFVReaction
variable = superficial_v
coeff = ${reaction}
[]
[p_diffusion]
type = LinearFVPressureCorrectionDiffusionJump
variable = pressure
rhie_chow_user_object = rc
use_nonorthogonal_correction = ${nonorthogonal}
[]
[HbyA_divergence]
type = LinearFVDivergence
variable = pressure
face_flux = HbyA
force_boundary_execution = true
[]
[]
[LinearFVBCs]
[velocity_x]
type = LinearFVAdvectionDiffusionFunctorDirichletBC
boundary = 'left right top bottom'
variable = superficial_u
functor = 0
[]
[velocity_y]
type = LinearFVAdvectionDiffusionFunctorDirichletBC
boundary = 'left right top bottom'
variable = superficial_v
functor = 0
[]
[pressure_flux]
type = LinearFVPressureFluxBC
boundary = 'left right top bottom'
variable = pressure
HbyA_flux = HbyA
Ainv = Ainv
rho = density
u = superficial_u
v = superficial_v
[]
[]
[FunctorMaterials]
[density]
type = ParsedFunctorMaterial
property_name = density
functor_names = 'exact_density'
expression = 'exact_density'
[]
[porosity]
type = ParsedFunctorMaterial
property_name = porosity
expression = 'if(x-${skew}*y<${interface},${eps_left},${eps_right})'
[]
[pressure_error]
type = ParsedFunctorMaterial
property_name = pressure_error
functor_names = 'pressure exact_pressure'
expression = 'pressure-exact_pressure'
[]
[speed]
type = ParsedFunctorMaterial
property_name = speed
functor_names = 'superficial_u superficial_v'
expression = 'sqrt(superficial_u^2+superficial_v^2)'
[]
[]
[AuxVariables]
[T_fluid]
type = MooseLinearVariableFVReal
[]
[]
[AuxKernels]
[T_fluid]
type = FunctorAux
variable = T_fluid
functor = boussinesq_temperature
execute_on = INITIAL
[]
[]
[Functions]
[boussinesq_temperature]
type = ParsedFunction
expression = 'T_ref-rho/alpha'
symbol_names = 'T_ref rho alpha'
symbol_values = '${T_ref} exact_density ${alpha}'
[]
[height]
type = ParsedFunction
expression = '-(gx*x+gy*y)/sqrt(gx^2+gy^2)'
symbol_names = 'gx gy'
symbol_values = '${gx} ${gy}'
[]
[exact_density]
type = ParsedFunction
expression = 'rho_0+strat*hz'
symbol_names = 'rho_0 strat hz'
symbol_values = '${rho_0} ${strat} height'
[]
# Hydrostatic pressure with the pin at (0.3, 0.3), inside a cell on 2^n meshes, set to zero.
[exact_pressure]
type = ParsedFunction
expression = '-sqrt(gx^2+gy^2)*(rho_0*(hz-hp)+strat*(hz^2-hp^2)/2)'
symbol_names = 'gx gy rho_0 strat hz hp'
symbol_values = '${gx} ${gy} ${rho_0} ${strat} height '
'${fparse -(gx*(0.3+skew*0.3)+gy*0.3)/sqrt(gx^2+gy^2)}'
[]
[]
[Executioner]
type = SIMPLE
momentum_l_abs_tol = 1e-13
pressure_l_abs_tol = 1e-13
momentum_l_tol = 0
pressure_l_tol = 0
momentum_l_max_its = 100
pressure_l_max_its = 100
rhie_chow_user_object = rc
momentum_systems = 'u_system v_system'
pressure_system = pressure_system
momentum_equation_relaxation = 0.7
pressure_variable_relaxation = 0.5
# At rest the normalized momentum residual has no flow to scale against and stalls near 1e-4,
# so the absolute tolerances below are not reached. The solution is fixed well before 50
# iterations.
num_iterations = 50
continue_on_max_its = true
pressure_absolute_tolerance = 1e-12
momentum_absolute_tolerance = 1e-12
momentum_petsc_options_iname = '-pc_type -pc_hypre_type'
momentum_petsc_options_value = 'hypre boomeramg'
pressure_petsc_options_iname = '-pc_type -pc_hypre_type'
pressure_petsc_options_value = 'hypre boomeramg'
print_fields = false
pin_pressure = true
pressure_pin_value = 0
pressure_pin_point = '${fparse 0.3 + skew * 0.3} 0.3 0'
[]
[Postprocessors]
[max_speed]
type = ElementExtremeFunctorValue
functor = speed
value_type = max
execute_on = FINAL
[]
# The pin sits at a point, not a cell centroid, so the error is compared up to a constant.
[max_pressure_error]
type = ElementExtremeFunctorValue
functor = pressure_error
value_type = max
execute_on = FINAL
outputs = none
[]
[min_pressure_error]
type = ElementExtremeFunctorValue
functor = pressure_error
value_type = min
execute_on = FINAL
outputs = none
[]
[pressure_error_range]
type = ParsedPostprocessor
pp_names = 'max_pressure_error min_pressure_error'
expression = 'max_pressure_error-min_pressure_error'
execute_on = FINAL
[]
[]
[Outputs]
[csv]
type = CSV
execute_on = FINAL
[]
[]