INSFVTurbulentViscosityWallFunction

Implements wall function boundary condition for the turbulent dynamic viscosity .

The boundary conditions are different depending on where the centroid of the cell near the identified boundary lies in the wall function profile. Taking the non-dimensional wall distance as , the three regions of the boundary layer are identified as follows:

  • Sub-laminar region:

  • Buffer region:

  • Logarithmic region:

The wall function goal is to set the total viscosity at the wall , decomposed as , such that the wall shear stress is accurately captured without the need of fully resolving the gradients at the near wall region.

where:

  • is the total viscosity evaluated at the wall face

  • is the turbulent viscosity, evaluated at the wall for the purpose of this boundary condition

  • is the dynamic viscosity, evaluated at the wall for the purpose of this boundary condition

  • is the wall-shear stress

  • is the wall-parallel velocity at the centroid

  • is the wall normal distance to the centroid

To impose a correct boundary condition for , as seen in the Equation above, we need to compute using analytical relationships between the wall shear stress and the dimensionless wall distance . For this purpose, four different formulations are supported as defined by the "wall_treatment" parameter.

To set the grid spacing for the first cell near the wall in your mesh, we recommend using the RANSYPlusAux auxiliary kernel. to estimate the dimensionless wall distance .

Equilibrium wall functions using a Newton solve

This treatment can be enabled by setting the parameter "wall_treatment" to eq_newton. The treatment uses equilibrium wall functions where the following formulation is used for the turbulent viscosity.

where:

  • is the density

  • is the dynamic viscosity

  • is the friction velocity and is the wall friction

  • is the distance from the boundary to the center of the near-wall cell

  • is the parallel velocity to the boundary computed at the center of the near-wall cell

For the buffer layer, a linear blending method is used that defines the turbulent viscosity as follows:

Note that for and we recover the sub-laminar and logarithmic profiles, respectively.

Here the standard or equilibrium law of the wall defines and as follows:

where:

  • is the molecular dynamic viscosity

  • is a closure parameter

  • is the von Kármán constant

In this method, we iterate on the wall function and to find via a Newton solve. Once is defined, is computed followed by the determination of the boundary turbulent viscosity.

commentnote

eq_newton solve will converge the fastest for simple flow geometries but it may diverge for more complicated flows. Also, the code will run if the center of the near wall cells are in the buffer layer. However, using a mesh that contains nodes in the buffer layer is not recommended.

Equilibrium wall functions using a fixed-point solve

This treatment is enabled by setting parameter "wall_treatment" to eq_incremental. The method uses the same equilibrium wall treatment than the Newton solve. However, the main difference is that, instead of computing for the near wall cells, a fixed point iteration is performed in the wall functions to find .

commentnote

eq_incremental has a larger convergence radius than the Newton solve and internal controls are added to avoid issues converging the wall function at the buffer layer. However, it will take more iterations than the Newton solve to converge. Using a mesh that contains nodes in the buffer layer is not recommended.

Equilibrium wall functions using linearized wall function

This treatment is enabled by setting parameter "wall_treatment" to eq_linearized. The treatment uses a linearized version of the wall function, in which a linear Taylor approximation is used for the natural logarithm. This approximation results in a quadratic equation that is solved directly for . Then, is computed from .

commentnote

eq_linearized will work fast as there is no nonlinear solve at the near-wall region. However, the method may introduce significant near-wall errors. The method is designed to be used in conjunction with porous media treatment and not necessarily for free flow.

Non-equilibrium wall functions

This treatment is enabled by setting parameter "wall_treatment" to neq. In this case, the non-dimensional wall distance is computed from the turbulent kinetic energy near the wall as follows:

where:

  • is a fitting parameter

  • is the turbulent kinetic energy at the centroid of the near-wall cell

Then, the turbulent viscosity is defined as follows:

For the buffer layer, a linear blending method is used that defines the turbulent viscosity as follows:

commentnote

neq should mainly be used for detached flow or other cases for which equilibrium wall functions are not valid. One should try to use equilibrium wall functions when possible.

Input Parameters

  • boundaryThe list of boundary IDs from the mesh where this object applies

    C++ Type:std::vector<BoundaryName>

    Controllable:No

    Description:The list of boundary IDs from the mesh where this object applies

  • muDynamic viscosity. A functor is any of the following: a variable, a functor material property, a function, a postprocessor or a number.

    C++ Type:MooseFunctorName

    Unit:(no unit assumed)

    Controllable:No

    Description:Dynamic viscosity. A functor is any of the following: a variable, a functor material property, a function, a postprocessor or a number.

  • mu_tThe turbulent viscosity. A functor is any of the following: a variable, a functor material property, a function, a postprocessor or a number.

    C++ Type:MooseFunctorName

    Unit:(no unit assumed)

    Controllable:No

    Description:The turbulent viscosity. A functor is any of the following: a variable, a functor material property, a function, a postprocessor or a number.

  • rhoDensity. A functor is any of the following: a variable, a functor material property, a function, a postprocessor or a number.

    C++ Type:MooseFunctorName

    Unit:(no unit assumed)

    Controllable:No

    Description:Density. A functor is any of the following: a variable, a functor material property, a function, a postprocessor or a number.

  • uThe velocity in the x direction. A functor is any of the following: a variable, a functor material property, a function, a postprocessor or a number.

    C++ Type:MooseFunctorName

    Unit:(no unit assumed)

    Controllable:No

    Description:The velocity in the x direction. A functor is any of the following: a variable, a functor material property, a function, a postprocessor or a number.

  • variableThe name of the variable that this boundary condition applies to

    C++ Type:NonlinearVariableName

    Unit:(no unit assumed)

    Controllable:No

    Description:The name of the variable that this boundary condition applies to

Required Parameters

  • C_mu0.09Coupled turbulent kinetic energy closure.

    Default:0.09

    C++ Type:double

    Unit:(no unit assumed)

    Controllable:No

    Description:Coupled turbulent kinetic energy closure.

  • displacementsThe displacements

    C++ Type:std::vector<VariableName>

    Unit:(no unit assumed)

    Controllable:No

    Description:The displacements

  • matrix_onlyFalseWhether this object is only doing assembly to matrices (no vectors)

    Default:False

    C++ Type:bool

    Controllable:No

    Description:Whether this object is only doing assembly to matrices (no vectors)

  • tkeThe turbulent kinetic energy. A functor is any of the following: a variable, a functor material property, a function, a postprocessor or a number.

    C++ Type:MooseFunctorName

    Unit:(no unit assumed)

    Controllable:No

    Description:The turbulent kinetic energy. A functor is any of the following: a variable, a functor material property, a function, a postprocessor or a number.

  • vThe velocity in the y direction. A functor is any of the following: a variable, a functor material property, a function, a postprocessor or a number.

    C++ Type:MooseFunctorName

    Unit:(no unit assumed)

    Controllable:No

    Description:The velocity in the y direction. A functor is any of the following: a variable, a functor material property, a function, a postprocessor or a number.

  • wThe velocity in the z direction. A functor is any of the following: a variable, a functor material property, a function, a postprocessor or a number.

    C++ Type:MooseFunctorName

    Unit:(no unit assumed)

    Controllable:No

    Description:The velocity in the z direction. A functor is any of the following: a variable, a functor material property, a function, a postprocessor or a number.

  • wall_treatmentneqThe method used for computing the wall functions

    Default:neq

    C++ Type:MooseEnum

    Options:eq_newton, eq_incremental, eq_linearized, neq

    Controllable:No

    Description:The method used for computing the wall functions

Optional Parameters

  • absolute_value_vector_tagsThe tags for the vectors this residual object should fill with the absolute value of the residual contribution

    C++ Type:std::vector<TagName>

    Controllable:No

    Description:The tags for the vectors this residual object should fill with the absolute value of the residual contribution

  • extra_matrix_tagsThe extra tags for the matrices this Kernel should fill

    C++ Type:std::vector<TagName>

    Controllable:No

    Description:The extra tags for the matrices this Kernel should fill

  • extra_vector_tagsThe extra tags for the vectors this Kernel should fill

    C++ Type:std::vector<TagName>

    Controllable:No

    Description:The extra tags for the vectors this Kernel should fill

  • matrix_tagssystemThe tag for the matrices this Kernel should fill

    Default:system

    C++ Type:MultiMooseEnum

    Options:nontime, system

    Controllable:No

    Description:The tag for the matrices this Kernel should fill

  • vector_tagsnontimeThe tag for the vectors this Kernel should fill

    Default:nontime

    C++ Type:MultiMooseEnum

    Options:nontime, time

    Controllable:No

    Description:The tag for the vectors this Kernel should fill

Contribution To Tagged Field Data 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.

  • implicitTrueDetermines whether this object is calculated using an implicit or explicit form

    Default:True

    C++ Type:bool

    Controllable:No

    Description:Determines whether this object is calculated using an implicit or explicit form

  • search_methodnearest_node_connected_sidesChoice of search algorithm. All options begin by finding the nearest node in the primary boundary to a query point in the secondary boundary. In the default nearest_node_connected_sides algorithm, primary boundary elements are searched iff that nearest node is one of their nodes. This is fast to determine via a pregenerated node-to-elem map and is robust on conforming meshes. In the optional all_proximate_sides algorithm, primary boundary elements are searched iff they touch that nearest node, even if they are not topologically connected to it. This is more CPU-intensive but is necessary for robustness on any boundary surfaces which has disconnections (such as Flex IGA meshes) or non-conformity (such as hanging nodes in adaptively h-refined meshes).

    Default:nearest_node_connected_sides

    C++ Type:MooseEnum

    Options:nearest_node_connected_sides, all_proximate_sides

    Controllable:No

    Description:Choice of search algorithm. All options begin by finding the nearest node in the primary boundary to a query point in the secondary boundary. In the default nearest_node_connected_sides algorithm, primary boundary elements are searched iff that nearest node is one of their nodes. This is fast to determine via a pregenerated node-to-elem map and is robust on conforming meshes. In the optional all_proximate_sides algorithm, primary boundary elements are searched iff they touch that nearest node, even if they are not topologically connected to it. This is more CPU-intensive but is necessary for robustness on any boundary surfaces which has disconnections (such as Flex IGA meshes) or non-conformity (such as hanging nodes in adaptively h-refined meshes).

  • 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