EXTERNAL_CODE_SURFACE

Specifies a fluid surface that interacts with a solid/structural surface from an external code.

Type

AcuSolve Command

Syntax

EXTERNAL_CODE_SURFACE("name") {parameters...}

Qualifier

User-given name.

Parameters

shape (enumerated) [no default]

Shape of the surfaces in this set.

three_node_triangle or tri3: Three-node triangle.
four_node_quad or quad4: Four-node quadrilateral
six_node_triangle or tri6: Six-node triangle.

element_set or elem_set (string) [no default]

User-given name of the parent element set.

surfaces (array) [no default]

List of element surfaces.

surface_sets (list) [={}]

List of surface set names (strings) to use in this command. When using this option, the connectivity, shape, and parent element of the surfaces are provided by the surface set container and it is unnecessary to specify the shape, element_set and surfaces parameters directly to this command. This option is used in place of directly specifying these parameters. In the event that both of the surface_sets and surfaces parameters are provided, the full collection of surface elements is read and a warning message is issued. The surface_sets option is the preferred method to specify the surface elements. This option provides support for mixed element topologies and simplifies pre-processing and post-processing.

coupling_type (enumerated) [=structural]

Manner in which the AcuSolve surface is coupled with the external code.

structural: AcuSolve surface is coupled with either a line or surface element set in the external code. This option requires mesh_displacement_type = tied when coupling to line elements.
line: AcuSolve surface is coupled with a line element set in the external code. This option requires mesh_displacement_type = tied.
surface: AcuSolve surface is coupled with a surface element set in the external code.
rigid_body: AcuSolve surface is coupled with a rigid body in the external code.

coupling_direction (enumerated) [=both]

External code coupling direction for the surface.

both: Exchanges information with the external code object in both directions. AcuSolve sends loading to the external code and the external code sends displacements back to AcuSolve.
to_external_code: AcuSolve sends loading information to the external code, but no displacement information is returned.
from_external_code: AcuSolve does not send loading information to the external code, but displacement information is provided to AcuSolve at each step.

rigid_body_name (string) [no default]

Name of the rigid body the external code surface is coupled with. Used with coupling_type = rigid_body.

velocity_type (enumerated) [=wall]

Type of the velocity boundary condition.

wall: Fluid follows the solid (no-slip).
slip: Fluid slips on the solid.

temperature_type (enumerated) [=tied]

Type of the temperature boundary condition.

none: No fluid temperature boundary condition (adiabatic).
tied: Fluid temperature same as solid wall.

mesh_displacement_type (enumerated) [=tied]

Type of the mesh displacement boundary condition.

tied: Fluid mesh is fixed to surface.
slip: Fluid mesh slides on the solid.

turbulence_wall_type (enumerated) [=wall_function]

Type of the turbulence wall modeling. Used with wall velocity type.

none: No wall modeling. When this option is set, the surface does not participate in the wall distance calculation for turbulence and no wall modeling is performed.
low_reynolds_number or low_re: Low Reynolds number damping functions.
wall_function or func: Turbulence wall function. Requires roughness_height.
running_average_wall_function: Turbulence wall function based on running average variables. Requires roughness_height.

roughness_height (real) >=0 [=0]

Average wall roughness height. Used with low_reynolds_number, wall_function and running_average_wall_function turbulence wall types.

wall_function_heat_flux_factor >=1 [=1]

Constant factor used to scale the turbulent thermal conductivity within the first element off the wall. Used with turbulence_wall_type = wall_function and running_average_wall_function.

external_code_tags (list) [={}]

Array of strings used to this fluid surface to solid surfaces. The null list matches to all solid surfaces and beams.

precedence (integer) [=1]

Precedence of the nodal boundary conditions defined here with respect to others defined elsewhere. Highest value has precedence on a per-variable basis.

gap_factor (real) >=0 [=1]

Nondimensional (with respect to the length of an element face) maximum gap allowed for two element faces to be in contact. No maximum if zero.

gap (real) >=0 [=0]

Dimensional maximum gap allowed for two element faces to be in contact. No maximum if zero.

Description

This command specifies a set of surfaces (element faces) to be used to interact with the solid surfaces in an external code in order to solve Direct Coupling Fluid Structure Interaction (DC-FSI) problems. For example,

EXTERNAL_CODE_SURFACE( "fluid wetted surface" ){
 shape                   = four_node_quad
 element_set             = "fluid region"
 surfaces                = { 1, 101, 1, 3, 11, 12 ;
                             2, 102, 3, 5, 13, 14 ; }
 velocity_type           = wall
 temperature_type        = tied
 mesh_displacement_type  = slip
 turbulence_wall_type    = wall_function
 roughness_height        = 0
 precedence              = 1
 gap_factor              = 1
 gap                     = 0
}

There are two main forms of this command. The legacy version (or single topology version) of the command relies on the use of the surfaces parameter to define the surfaces. When using this form of the command, all surfaces within a given set must have the same shape, and it is necessary to include both the element_set and shape parameters in the command. shape specifies the shape of the surface. This shape must be compatible with the shape of the "parent" element set whose user-given name is provided by element_set. The element set shape is specified by the shape parameter of the ELEMENT_SET command. The compatible shapes are:

Element Shape: Surface Shape
four_node_tet: three_node_triangle
five_node_pyramid: three_node_triangle
five_node_pyramid: four_node_quad
six_node_wedge: three_node_triangle
six_node_wedge: four_node_quad
eight_node_brick: four_node_quad
ten_node_tet: six_node_triangle

The surfaces parameter contains the faces of the element set. This parameter is a multi-column array. The number of columns depends on the shape of the surface. For three_node_triangle, this parameter has five columns, corresponding to the element number (of the parent element set), a unique (within this set) surface number, and the three nodes of the element face. For four_node_quad, surfaces has six columns, corresponding to the element number, a surface number, and the four nodes of the element face. For six_node_triangle, surfaces has eight columns, corresponding to the element number, a surface number, and the six nodes of the element face. One row per surface must be given. The three, four, or six nodes of the surface may be in any arbitrary order, since they are reordered internally based on the parent element definition.

The surfaces may be read from a file. For the above example, the surfaces may be placed in a file, such as dcfsi.wet.ebc:

1 101 1 3 11
2 102 3 5 13

and read by:

EXTERNAL_CODE_SURFACE( "fluid wetted surface" ) {
 shape         = four_node_quad
 element_set   = "fluid region"
 surfaces      = Read( "dcfsi.wet.ebc" )
 ...
}

The mixed topology form of the EXTERNAL_CODE_SURFACE command provides a more powerful and flexible mechanism for defining the surfaces. Using this form of the command, it is possible to define a collection of surfaces that contains different element shapes. This is accomplished through the use of the surface_sets parameter. The element faces are first created in the input file using the SURFACE_SET command, and are then referred to by the EXTERNAL_CODE_SURFACE command. For example, a collection of triangular and quadrilateral element faces can be defined using the following SURFACE_SET commands.

SURFACE_SET( "tri faces" ) {
    surfaces       = { 1, 1, 1, 2, 4 ;
                       2, 2, 3, 4, 6 ;
                       3, 3, 5, 6, 8 ; }
    shape          = three_node_triangle
    volume_set     = "tetrahedra"
}
SURFACE_SET( "quad faces" ) {
    surfaces       = { 1, 1, 1, 2, 4, 9 ;
                       2, 2, 3, 4, 6, 12 ;
                       3, 3, 5, 6, 8, 15 ; }
    shape          = four_node_quad
    volume_set     = "prisms"

Then, a single EXTERNAL_CODE_SURFACE command is defined that contains the tri and quad faces as follows:

EXTERNAL_CODE_SURFACE ( "fluid wetted surface" ) {
   surface_sets       = {"tri_faces", "quad_faces"}
   ...
}

The list of surface sets can also be placed in a file, such as surface_sets.srfst:

tri faces
quad faces

and read using:

EXTERNAL_CODE_SURFACE ( "fluid wetted surface" ) {
   surface_sets       = Read("surface_sets.srfst")
   ...
}

The mixed topology version of the EXTERNAL_CODE_SURFACE command is preferred. This version provides support for multiple element topologies within a single instance of the command and simplifies pre-processing and post-processing. In the event that both the surface_sets and surfaces parameters are provided in the same instance of the command, the full collection of surface elements is read and a warning message is issued. Although the single and mixed topology formats of the commands can be combined, it is strongly recommended that they are not.

The fluid forces, moments, and heat fluxes are communicated from all the surfaces defined in EXTERNAL_CODE_SURFACE commands to an external solid/structural code defined by the EXTERNAL_CODE command. Mesh displacements and temperatures are returned from the external code to the same surfaces. For each quadrature point of each external code surface element face, a search is made over all appropriate solid model faces in the external code for:

The distance between the point and the face is less than gap; and
The distance between the point and the face, normalized by the length of the face, is less than gap_factor.

Each constraint is ignored if the corresponding parameter is zero. If both parameters are zero, then there are no constraints and each quadrature point is guaranteed to be in contact with another face. Fluid forces are actually applied to the solid model only if the fluid quadrature point is determined to be in contact with a solid face. Similarly, nodal boundary conditions from the solid model are applied only if the solid model node is in contact with the external code surface.

The search over solid surfaces may be constrained through the use of tags. For example,

EXTERNAL_CODE_SURFACE( "Drill" ) {
   ...
   external_code_tags = {"0"}
   ...
}
EXTERNAL_CODE_SURFACE( "Riser" ) {
   ...
   external_code_tags = {}
   ...
}

The "Drill" surface will be matched only to solid surfaces tagged with "0", while the "Riser" surface will be matched to all solid surfaces.

A coupling_type = structural indicates that all surfaces participating in the exchange between AcuSolve and the external code are of a single, consistent element type (that is line/beam elements or surface elements). For example, if a simulation contains five EXTERNAL_CODE_SURFACE commands, they must all be coupled to line elements or surface elements in the structural model. Prior to the release of AcuSolve 13.0, it was only possible to couple with a single type and this option is therefore supplied for backward compatibility. Starting in AcuSolve 13.0, it is possible to couple with surface elements, line elements and rigid body surfaces within a single simulation. This is accomplished by explicitly defining the coupling_type parameter for each EXTERNAL_CODE_SURFACE command that is issued.

Note: If a coupling_type = structural is used in the same simulation in which a coupling_type = line, coupling_type = surface or coupling_type = rigid_body is specified, an assertion will be issued and the code will exit.

This EXTERNAL_CODE_SURFACE command determines all the boundary conditions on the wetted surface, that is, all the points that are determined to be in contact, if precedence is sufficiently high. The parameter mesh_displacement_type may be either slip, allowing the mesh to slide against the solid, such as in a half-filled tank,; or tied, where the fluid mesh displacement is tied to the solid. For slip, the solid surface acts just like a guide surface; see the description of guide_surface type in the NODAL_BOUNDARY_CONDITION command for details about the algorithm used. If velocity_type is set to wall, the fluid velocity moves with the solid wall. If viscous effects are not important, it may be set to slip. For the former case, turbulence nodal boundary conditions are set automatically. Wall modeling is also set with turbulence_wall_type and roughness_height.

Temperature is set equal to the solid temperature if temperature_type is tied, otherwise the wetted surface is adiabatic, unless other temperature boundary conditions are specified on the surface.