# DC-FSI using Radioss and AcuSolve

- Develop Radioss structural model and an AcuSolve-only fluid model, and ensure that the uncoupled analyses run successfully.
- Prepare the stand-alone models that include DC-FSI commands.
- Run the coupled analysis.
- Post-process the FSI solution.

This workflow ensures that both the Radioss and the AcuSolve models are defined properly prior to performing a coupled simulation. Radioss and AcuSolve do not require that the analysis be run with a particular unit system, but both analyses need to use a consistent unit system. As a rule, all quantities exchanged between the two solvers will be in dimensional form, and the components of all vector quantities will be resolved in the inertial frame. For consistency, identical inertial frames must be selected for Radioss and AcuSolve.

## Radioss Model

- Create input deck for Radioss
- Identify the interface region and the solution quantities exchanged
- Define the communication scheme

```
/IMPL/DYNA/FSI
ESET SSET PORT MINX MAXX TAG DATA MSG WAIT INIT
FTOL DTOL TTOL XTOL
```

Each of the data items are discussed below under their relevant topic.

## Damp Surfaces

The damp surface of the structural mesh must be specified in the Radioss FSI input data. The damp surface can either be specified by a group of elements or a surface. Note that the structural mesh on the damp surface does not have to match the interfacing fluid mesh. AcuSolve will internally project the CFD tractions from the fluid interface mesh onto a non-matching damp surface structural mesh. The mapping of nodal forces is also supported for structural beam elements. For example, a rod, pipe or blade can be modeled with simple beam elements in the structural mesh. The corresponding fluid mesh will contain the actual three-dimensional geometry of these beam elements.

If the damp surface is specified by a group of elements (ESET), use the /GRBEAM/BEAM/, /GRSHEL/SHEL/, or /GRSH3N/SH3N/ data for beam, 4-node, and 3-node shell elements, respectively. It is possible to specify the damp surface of a solid by coating it with shell elements and then assigning these elements zero material properties using the /MAT/LAW0 data. If the damp surface consists of beam elements, then these must be specified using the beam element group data. The ID of the element group is the first item of the /IMPL/DYNA/FSI data.

The matching fluid surface is specified in the AcuSolve data using
the `EXTERNAL_CODE_SURFACE`

command.

In some cases a portion of the structural damp surface must be "tagged" so that AcuSolve can associate it with the AcuSolve boundary surface. This is done by specifying the Radioss part ID as the ```
external_code_tags
parameter
```

in the `EXTERNAL_CODE_SURFACE`

data.

```
EXTERNAL_CODE_SURFACE( "Drill" ) {
...
external_code_tags = {"10"}
...
}
```

Data is used to specify that this surface corresponds to the Radioss
part with ID `10`

. Note that each individual surface must consist of
elements with the same part ID, and each separate surface must consist of elements with
separate part ID's. In order to apply a tag, the surface of a solid structure, the solid
must be coated with shell elements and the property ID of these shell elements used as
the surface tag. To specify the use of surface tags, set item `10`

of the
/IMPL/DYNA/FSI data (TAG) to `1`

.

## AcuSolve Model

- Set the analysis parameters to include an external field.
- Define the solution strategy.
- Define the external surface definition.

## Analysis Parameter Setup to include an External Field

Use the EQUATION command to specify the solution fields available or the
system of equation that are present in the problem. To include a field that is computed
with an external solver, for Radioss, set the
`external_code parameter`

to '`ON`

'.

`ON`

the `external_code`

parameter and allow for arbitrary mesh movement by setting the `mesh`

parameter to
`arbitrary_lagrange_eulerian`

.```
EQUATION {
flow = navier_stokes
mesh = arbitrary_lagrange_eulerian
external_code = on
}
```

## Define Solution Strategy

In conjunction to the EQUATION command, which specifies the existence of solution fields in the problem, you must use TIME_SEQUENCE and STAGGER commands to define time stepping and staggering strategy. The preferred method is to use the AUTO_SOLUTION_STRATEGY command to have AcuSolve generate the solution strategy commands. In order to highlight the solution strategy commands, highlight the TIME_SEQUENCE and STAGGER commands.

```
TIME_SEQUENCE {
min_time_steps = 1
max_time_steps = 15
:
min_stagger_iterations = 1
max_stagger_iterations = 20
staggers = { "external_code",
"mesh_displacement",
"flow",
"turbulence" }
}
```

`external_code`

,
`mesh_displacement`

, and `flow`

equations.```
STAGGER ( "external_code” ) {
equation = external_code
min_stagger_iterations = 1
max_stagger_iterations = 10
}
STAGGER( "mesh_displacement" ) {
equation = mesh_displacement
min_stagger_iterations = 1
max_stagger_iterations = 5
convergence_tolerance = 0.1
linear_solver = conjugate_gradient
min_linear_solver_iterations = 10
max_linear_solver_iterations = 1000
linear_solver_tolerance = 0.001
projection = off
}
STAGGER( "flow" ) {
equation = flow
min_stagger_iterations = 1
max_stagger_iterations = 2
convergence_tolerance = 0.1
lhs_update_frequency = 1
linear_solver = gmres
linear_solver_tolerance = 0.1
}
```

## Define Fluid-Structure Interface

Use the EXTERNAL_CODE_SURFACE command to define the interface between the fluid and structure. The command specifies the surface topology, as well as the interface proprieties.

`velocity_type`

,
`temperature_type`

, and `mesh_displacement_type`

define
the interface properties (boundary conditions) and
are:```
EXTERNAL_CODE_SURFACE( "wall" ) {
surfaces = Read( "MESH.DIR/wall.ebc" )
shape = "three_node_triangle"
element_set = "tet fluid"
velocity_type = wall
temperature_type = tied
mesh_displacement_type = tied
gap = 0
gap_factor = 0
external_code_tags = {}
}
```

The interface properties or boundary conditions are specified through the `mesh_displacement_type`

, `velocity_type`

, and `temperature_type`

parameters. The `mesh_displacement`

parameter defines whether the fluid mesh is tied to the solid mesh or allowed to slip against the solid mesh surface. Set the `mesh_displacement_type=tied`

to tie the fluid mesh to the solid mesh, or `mesh_displacement_type=slip`

to allow the fluid mesh to slide against the solid surface, which acts as a guide surface.

The `velocity_type`

specifies how the fluid velocity behaves in relation to the structural mesh velocity. Set `velocity_type=wall`

to tie the fluid velocity to the mesh velocity, or set `velocity_type=slip`

for the normal component of the fluid velocity to be tied to the solid mesh velocity.

There are four possible interface combinations based on the settings of the
`mesh_displacement`

and `velocity_type`

parameters.
These are summarized in Table 1.

Fluid-Solid Interface Conditions | Mesh Displacement | ||
---|---|---|---|

Tied | Slip | ||

Velocity Type | Wall |
${x}_{fluid}={x}_{solid}$
${u}_{fluid}=\left({x}_{fluid}^{n+1}-\text{\hspace{0.17em}}\text{\hspace{0.17em}}{x}_{fluid}^{n}\right)/\text{\Delta}t$ |
${x}_{fluid}\in {S}_{solid}$
${u}_{fluid}\u2022n=\left({x}_{fluid}^{n+1}-{x}_{fluid}^{n}\right)/\text{\Delta}t\u2022n$ ${u}_{fluid}\u2022{t}_{i}=\left({x}_{solid}^{n+1}-{x}_{solid}^{n}\right)/\text{\Delta}t\u2022{t}_{i}\text{\hspace{0.17em}}i=1,2$ |

Slip |
${x}_{fluid}={x}_{solid}$
${u}_{fluid}\u2022n=\left({x}_{fluid}^{n+1}-{x}_{fluid}^{n}\right)/\text{\Delta}t\u2022n$ |
${x}_{fluid}\in {S}_{solid}$
${u}_{fluid}\u2022n=\left({x}_{fluid}^{n+1}-{x}_{fluid}^{n}\right)/\text{\Delta}t\u2022n$ |

When the fluid is allowed to slide along the solid mesh, neighborhood searches between the fluid
and solid meshes are continuous performed. The `gap_factor`

parameter
specifies a non-dimensional (with respect to the length of the element face) maximum
allowable gap and the gap parameter specified a dimensional maximum gap distance between
each quadrature point of the AcuSolve surface to the closest
surface given by Radioss to check for gaps. If the distance
is greater than the gap, the computation stops with an error message.