Dynamic Mesh Case Studies

(FLUENT 6.1)
Christoph Hiemcke
9 June 2004
 Purpose of this session

• Show you how to use the controls for the Dynamic Mesh
(DM) model, based on a few examples

• Show you how to write simple UDFs that control the

dynamic zones, based on a few examples

• Show you the new features in FLUENT 6.2

• To have the examples motivate you – what application

might you use the model for ?

Slide 0-1
 Agenda

Overview of the Dynamic Mesh (DM) Model

Dynamic Meshing Schemes:

i. Layering for Linear Motion
ii. Spring Smoothing for Small, General Motion
iii. Local Remeshing for Large, General Motion
iv. Local Remeshing with Size Functions

UDF Macros to Govern the Dynamic Mesh:

v. Coupled Mesh Motion via the 6 DOF UDF
vi. Controlling Rigid Body Motion using
DEFINE_CG_MOTION
vii. Controlling Projection onto Deforming Boundaries using
DEFINE_GEOM
viii. Controlling the Motion of Individual Nodes using
DEFINE_GRID_MOTION
ix. Miscellaneous UDF Examples

New Features in FLUENT 6.2

Slide 0-2
I. Overview of the Dynamic Mesh
(DM) Model

Slide 1-1
 What is the Dynamic Mesh (DM) Model?

ƒ A method by which the solver (FLUENT) can be instructed to move

boundaries and/or objects, and to adjust the mesh accordingly

‹ Examples:
z Automotive piston
moving inside a
cylinder
z A flap moving on
an airplane wing
z A valve opening
and closing
z An artery
expanding and
contracting

Volumetric fuel pump

Slide 1-2
 Why Use the Dynamic Mesh Model?

ƒ Used when rigid boundaries move with respect to each other, e.g.,

ƒ Piston moving w.r.t. an engine cylinder (linear motion)

ƒ Flap moving w.r.t. an airplane wing (rotating motion)
ƒ Two stages of a rocket that move away from each other (stage
separation)
ƒ A rescue pod being dropped from an airplane (store separation)

ƒ Used when boundaries deform, e.g.,

ƒ A balloon that is being inflated

ƒ An arterial wall responding to the pressure pulse from the heart
ƒ A solid propellant retreating as it is being consumed by the flame
ƒ The shrinking or extending walls of an engine cylinder as the piston
moves in and out

Slide 1-3
 Dynamic Mesh (DM) Model: Schemes

ƒ The DM model makes use of three meshing schemes, and we will

look at them one at a time in the next three sections:

ƒ Layering
ƒ Spring Smoothing
ƒ Local Remeshing

ƒ The topic of the next section is the layering method.

Slide 1-4
II. Layering for Linear Motion

Slide 2-1
 Layering: Introduction

ƒ Layering involves the creation

and destruction of cells;
ƒ Available for quad, hex and
wedge mesh elements;
ƒ Layering is used for purely
linear motion – two examples
are:
ƒ A piston moving inside a
cylinder (see animation);
ƒ A box on a conveyor belt.
ƒ We will now look at these two
examples.

Slide 2-2
 Layering Example 1: Piston
ƒ For the piston, the piston wall is
moved up and down;
ƒ The motion is governed by the “in-
cylinder” controls (see panel below):
Complex geometry near cylinder head
is tri meshed

Piston wall moves

Slide 2-3
 Layering Example 1: Piston

ƒ Cells are being split or collapsed

as the piston wall comes near
(explanation on the next page):

Slide 2-4
 Layering Example 1: Piston
ƒ Split if:
ƒ Collapse if:

h > (1 + α S )hideal
h < α c hideal

ƒ hideal is defined later,

during the definition of the
dynamic zones.

Slide 2-5
 Layering Example 1: Piston
ƒ Constant Height:
ƒ Every new cell layer has the same height;
ƒ Constant Ratio:
ƒ Maintain a constant ratio of cell heights
between layers (linear growth);
ƒ Useful when layering is done in curved Constant
domains (e.g. cylindrical geometry). Height
Edges “i” and
“i+1” have
same shape

Constant
Piston at Ratio
Initially, top-most Edge “i+1”
piston at position is an average
bottom-most
of edge “i”
position
and the
Edge “i” piston shape

Slide 2-6
 Layering Example 1: Piston
ƒ Definition of the
dynamic zone:

piston (wall zone) moves as a

rigid body in the y-direction
Slide 2-7
 Layering Example 1: Piston
ƒ Definition of the ideal
height of a cell layer;
ƒ hideal is about the same
as the height of a typical
cell in the model.

Slide 2-8
 Layering Example 2: Conveyor Belt

ƒ A box on a conveyor
belt moves through a
curing oven;
ƒ Layering is limited Cool exterior
to the fluid zone
adjacent to the box;
Hot air
ƒ Cell layers in the
dynamic zone slide Oven interior Static zone
past the static zone
at a non-conformal, box Dynamic zone
sliding grid
interface.
Grid interface

Slide 2-9
 Layering Example 2: Conveyor Belt

ƒ Layering is
limited to the
fluid zone
adjacent to the
box;
ƒ Cell layers in
the dynamic
zone slide past
the static zone
at a non-
conformal,
sliding grid
interface.

Slide 2-10
 Layering Example 2: Conveyor Belt

ƒ TIP: Within Gambit,

be sure that the two
fluid zones are
totally disconnected;
ƒ Even nodes on the
interface must be
disconnected (i.e.,
duplicate). Static zone

Dynamic zone

Faces are disconnected

here at the interface!

Slide 2-11
 Layering Example 2: Conveyor Belt

ƒ Dynamic Mesh Parameters:

ƒ Layering enabled;
ƒ “Constant Height” option
(explained before);
ƒ Set up split and collapse
factors (explained before).

Slide 2-12
 Layering Example 2: Conveyor Belt

ƒ A profile is read in to drive the motion at a

constant 1 m/s in the x-direction
(File > Read > Profile)
ƒ The fluid zone adjacent to the box will be FLUENT profile:
moved as a rigid body at constant speed;
ƒ Similarly, the box walls move as rigid bodies ((oven 2 point)
as well (otherwise the velocity boundary
conditions will not be correct). (time 0 15.0)

x-velocity
(v_x 1.0 1.0)
(m/s)
)
1.0

Time (sec)
0.0 15.0
Slide 2-13
 Layering Example 2: Conveyor Belt

ƒ Cell layers in the dynamic zone slide past the static zone at a non-
conformal, sliding grid interface;
ƒ Define > Grid Interfaces
ƒ The geometry of the interface is shown on the next slide.

Slide 2-14
 Layering Example 2: Conveyor Belt

ƒ Geometry of the non-conformal, sliding grid interface:

interface-top fluid-static
(three line
segments)

fluid-moving
interface-bottom
(single line
segment)

Slide 2-15
 Layering Example 2: Conveyor Belt

ƒ The fluid zone adjacent to the

box (called “fluid-moving”) is
moved as a rigid body at
constant speed;
ƒ The walls of the box (“wall-
box”) should also be specified
as dynamic zones that move as
a rigid body: otherwise the
wall velocities will be wrong;
ƒ The motion is governed by the
profile with the identifier
“oven”;
ƒ The CG location is given but
not needed, since there is no
rotation;
ƒ The next slide will discuss the
other two dynamic zones;

Slide 2-16
 Layering Example 2: Conveyor Belt

ƒ Cells are being split or collapsed at two edges on the domain boundary,
to the left and right of the box;
ƒ The two edges are defined as “stationary zones”.

“fluid-moving”

Cell creation at stationary Cell destruction at stationary

edge “inlet-left-bottom” edge “outlet-right-bottom”

Slide 2-17
 Layering Example 2: Conveyor Belt

ƒ The two “stationary

zones” are defined as
shown;
ƒ The ideal cell height is 0.1
m at both stationary
zones;
ƒ A new layer is created
when an old layer is
stretched beyond (1+0.4)*
0.1 = 0.14 m
ƒ An old layer is removed
once it shrinks to smaller
than 0.4 * 0.1 = 0.04 m
ƒ Let’s look at the motion
again.

Slide 2-18
 Layering Example 2: Conveyor Belt
ƒ Let’s look at the motion again:

Slide 2-19
 Layering: Further Examples

ƒ Fuel injector;
ƒ Flow solution on the next slide.

Slide 2-20
 Layering: Further Examples

ƒ Fuel injector;
ƒ Flow solution
(velocity contours).

Slide 2-21
 Layering: Further Examples

ƒ 2-stroke engine;
ƒ Layering.

ƒ Premixed combustion
(temperature contours)

Slide 2-22
 Layering: Further Examples

ƒ Vibromixer;
ƒ Layering;
ƒ Flow solution on
next slide.

Slide 2-23
 Layering: Further Examples

ƒ Vibromixer;
ƒ Layering;
ƒ Flow solution
(contours of
velocity).

Slide 2-24
 Agenda

Overview of the Dynamic Mesh (DM) Model

Dynamic Meshing Schemes:

i. Layering for Linear Motion
ii. Spring Smoothing for Small, General Motion
iii. Local Remeshing for Large, General Motion
iv. Local Remeshing with Size Functions

UDF Macros to Govern the Dynamic Mesh:

v. Coupled Mesh Motion via the 6 DOF UDF
vi. Controlling Rigid Body Motion using
DEFINE_CG_MOTION
vii. Controlling Projection onto Deforming Boundaries using
DEFINE_GEOM
viii. Controlling the Motion of Individual Nodes using
DEFINE_GRID_MOTION
ix. Miscellaneous UDF Examples

New Features in FLUENT 6.2

Slide 0-2
III. Spring Smoothing for
Small, General Motion

Slide 3-1
 Spring Smoothing: Introduction

ƒ If the relative motions of the boundaries are

small, then we would simply like to compress
or stretch the existing cells;
ƒ FLUENT uses a spring analogy, whereby any
two neighboring nodes are connected with a
spring. If any boundary deforms, the nodal
positions adjust until equilibrium is re-
established. We call this spring smoothing.
ƒ Examples:
ƒ Arterial walls responding to the pressure pulse
from the heart;
ƒ Pistons with small strokes;
ƒ Ablation of the internal surface in a rocket
engine, as the solid propellant is used up.

Slide 3-2
 Spring Smoothing

ƒ We will demonstrate the spring

smoothing feature of the dynamic mesh
(DM) model by means of an example:

ƒ Motion of a small-stroke, irregularly

shaped piston:

The iterative smoothing algorithm is controlled via the

Convergence Tolerance and the Number of Iterations

Slide 3-3
 Spring Smoothing Ex. 1: Irregular piston
ƒ The bottom wall (“piston”)
moves up and down;
ƒ Motion is via “in-cylinder”
tool
ƒ Smoothing uses default
parameters in this case.

piston
Slide 3-4
 Spring Smoothing Ex. 1: Irregular piston
ƒ The bottom wall (“piston”)
moves as a rigid body;
ƒ Under “Meshing Options” the
ideal cell height is specified as
0.02 meters;
ƒ What will happen?

“piston”
Slide 3-5
 Spring Smoothing Ex. 1: Irregular piston

ƒ Everything OK, except the

nodes on the vertical walls
need to move – they need to
be smoothed also!

Note how this

cell collapses

Slide 3-6
 Spring Smoothing Ex. 1: Irregular piston

ƒ The nodes belonging to “walls-vertical”

are set to “deforming”
ƒ The nodes will be projected onto the
walls of a cylinder of radius 0.15 m that
is aligned with the y-axis:
y
R 0.15
x

Cylinder walls (used “walls-vertical”

for projection)
Slide 3-7
 Spring Smoothing Ex. 1: Irregular piston

ƒ The nodes belonging to “walls-

vertical” are deformed by means of
the smoothing algorithm

ƒ For more info about

deforming zones, please
refer to the appendix of this lecture

ƒ Remeshing is not used here,

so none of the parameters are
relevant

ƒ So what happens with these settings?

Slide 3-8
 Spring Smoothing Ex. 1: Irregular piston

ƒ Everything OK!
ƒ One can also
project onto
planes or
user-defined
edges/surfaces.

Note how these

nodes move

Slide 3-9
 Spring Smoothing Ex. 1: Irregular Piston

ƒ What happens if we
change the spring
constant, k ?
ƒ We saw what
happens with the
default value:
k=1
ƒ The effect of the
moving wall is felt
mostly near the
moving wall, but not
at larger distances.

k=1

Slide 3-10
 Spring Smoothing Ex. 1: Irregular Piston

ƒ k ranges from 0 to 1;
ƒ Let us try k = 0,
which means the
stiffness is maximal;
ƒ The effect of the
moving wall is felt
everywhere, even
near the top wall.

k=0

Slide 3-11
 Spring Smoothing Ex. 1: Irregular Piston

ƒ k ranges from 0 to 1;
ƒ Let us try k = 0.5,
which implies a
medium stiffness;
ƒ The effect of the
moving wall is
strongly felt
throughout the
bottom half of the
domain.

k = 0.5

Slide 3-12
 Spring Smoothing Ex. 1: Irregular Piston

ƒ So far, we have seen the impact

of changing the spring constant
factor, k;
ƒ Next we will consider the
impact of changing the
boundary node relaxation, β
ƒ β controls the extent to which
the motion r of adjacent interior
nodes, ∆xadj , affects
r the
position of nodes, xb , on the
deforming boundary wall:
r r r
xbn +1 = xbn + β∆xadj

Slide 3-13
 Spring Smoothing Ex. 1: Irregular Piston

ƒ So far, we used β = 1,
the default value;
ƒ This means the
interior nodes fully
affect the movement
of the nodes on the
deforming boundary
wall;
ƒ The nodes on the
deforming wall move
in such a way as to
create nice cells
nearby.

β=1

Slide 3-14
 Spring Smoothing Ex. 1: Irregular Piston

ƒ If we use β = 0, the
nodes on the
deforming boundary
wall will not move at
all;
ƒ We quickly get
degenerate cells next
to the deforming
boundary.

β=0

Slide 3-15
 Spring Smoothing Ex. 1: Irregular Piston

ƒ If we use β = 0.5, the

nodes on the
deforming boundary
wall will move only
slightly;
ƒ We obtain very poor
cells next to the
deforming boundary
wall.

β = 0.5

Slide 3-16
 Agenda

Overview of the Dynamic Mesh (DM) Model

Dynamic Meshing Schemes:

i. Layering for Linear Motion
ii. Spring Smoothing for Small, General Motion
iii. Local Remeshing for Large, General Motion
iv. Local Remeshing with Size Functions

UDF Macros to Govern the Dynamic Mesh:

v. Coupled Mesh Motion via the 6 DOF UDF
vi. Controlling Rigid Body Motion using
DEFINE_CG_MOTION
vii. Controlling Projection onto Deforming Boundaries using
DEFINE_GEOM
viii. Controlling the Motion of Individual Nodes using
DEFINE_GRID_MOTION
ix. Miscellaneous UDF Examples

New Features in FLUENT 6.2

Slide 0-2
IV. Local Remeshing for
Large, General Motion

Slide 4-1
 Local Remeshing: Introduction

ƒ If the relative motions of the

boundaries are large and
general (both translation and
rotation may be involved), then
we need to remesh locally;
ƒ Why local remeshing? For
efficiency, FLUENT remeshes
only those cells that exceed the
specified maximum skewness
and/or fall outside the specified
range of cell volumes;
ƒ In the flowmeter shown, the
cuff rocks and reciprocates
(rotates and translates
sinusoidally).
Slide 4-2
 Local Remeshing: Algorithm

1. At the beginning of every time step:

ƒ Mark all cells whose skewness is above “Maximum Cell Skewness”
2. If ( time = (“Size Remesh Interval”) ⋅ ∆t ) then
ƒ Mark all cells whose volume is below
“Minimum Cell Volume”
or above “Maximum Cell Volume”
3. Locally remesh only the marked cells
ƒ “Must Improve Skewness”: remesh only
if the resulting cell will be less skewed
than before (almost always selected);
ƒ Several meshing strategies are tried to
arrive at the best result;
4. Perform smoothing iterations
(if smoothing is turned on);

Slide 4-3
 Local Remeshing: Introduction

ƒ Local Remeshing is used for cases involving large, general motion:

ƒ Cars passing (overtaking) each other;
ƒ Rescue capsule dropped from an airplane (store separation);
ƒ The motion of two intermeshing gears;
ƒ Two stages of a rocket separating from each other (stage separation).
ƒ Local remeshing is available for tri/tet meshes only.
ƒ We will look at one major example:
ƒ Butterfly valve;

Slide 4-4
 Local Remeshing Example 1:
Butterfly Valve

ƒ The butterfly valve

rotates, governed by
a profile;
ƒ Flow is from left to
right;
ƒ One challenge is that
the mesh is much
finer at the valve’s
tips than at its center;
ƒ The tip tends to leave
a “wake” of small
cells;
ƒ Small gaps require
3-5 cells, otherwise
one gets unphysical
velocities.
Slide 4-5
 Local Remeshing Ex. 1: Butterfly Valve

ƒ The mesh was made

in Gambit;
ƒ Valve radius is 0.1 m
ƒ Small gap (9 mm)
has 3 cells across;
ƒ The rounded portion
of the housing has a
variable cell size;
ƒ Minimum cell
length is about 3 mm
(0.003 m);
ƒ 1674 cells, max.
skewness 0.39

Slide 4-6
 Local Remeshing Ex. 1: Butterfly Valve

ƒ The motion of the butterfly valve is governed by a profile:

((butterfly 6 point)
(time 0 0.6 1.0 2.2 2.6 3.2)
(omega_z 0.0 1.571 1.571 -1.571 -1.571 0.0)
)

Omega_z (rad/s)
‹ The valve first rotates
CCW through 90 1.571
degrees, then CW; 3.2
0.0
‹ The maximum 0.6 Time (sec)
rotational speed is
15 RPM.
Slide 4-7
 Local Remeshing Ex. 1: Butterfly Valve

ƒ Use contours of Grid/CellVolume

(deselect “node values”) to find the
minimum and maximum cell volumes of
the initial mesh (in this case 3.06e-6 and
2.12e-4 m3);
ƒ Base your specification of the minimum
and maximum cell volumes on the initial
mesh;
ƒ Use contours of Grid/EquiangleSkew
(deselect “node values”) to find the
maximum skewness of the initial mesh;
ƒ Base your specification of the maximum
cell skewness on the initial mesh, and on
the rule-of-thumb: 0.7 for 2D, 0.85 for
3D.
Slide 4-8
 Local Remeshing Ex. 1: Butterfly Valve

ƒ Define > DynamicMesh > Zones

ƒ Select the wall of the valve
(“wall-butterfly”) and make it move
as a rigid body,
driven by the
profile “butterfly”;
ƒ The CG is located
at (0,0);
ƒ Ideal cell height is
0.003 m, based on
the smallest cell
length of the initial
mesh; hideal controls
the cell size adjacent
to the moving wall.
Slide 4-9
 Local Remeshing Ex. 1: Butterfly Valve

ƒ Previewing the mesh motion:

ƒ Choose a first time step based on the
length of the smallest cell and on the
maximum velocity;
ƒ In our case: ∆s 0.003m
∆t = = = 0.018s
v 0.16m / s
‹ We chose to display the
mesh motion to the screen,
and to:
‹ Capture every seventh frame
to disk (be sure to visit
File > Hardcopy before you
begin)

Slide 4-10
 Local Remeshing Ex. 1: Butterfly Valve

Spots with large cells

ƒ The preview fails
with these settings!
ƒ It is normal to have
to make some
adjustments
ƒ We analyze the
failed mesh:

The spots of large

cells indicate that
our preview time
step is too large

“Wake” of small cells, as expected

Slide 4-11
 Local Remeshing Ex. 1: Butterfly Valve

ƒ We succeed with
a preview time
step of 0.005 sec
ƒ Let us analyze
the mesh motion,
to make
improvements
later
ƒ Generally, we
look for:
ƒ Cell quality
(skewness)
ƒ Jumps in cell
size
ƒ Cell count

Slide 4-12
 Local Remeshing Ex. 1: Butterfly Valve

Large cells adjacent to the coarsely

meshed part of the housing
ƒ We are wasting
too many cells in
the “wake” of the
valve
ƒ Let us revisit the
dynamic mesh
parameters and
zones

“Wake” of small cells, as expected

Slide 4-13
 Local Remeshing Ex. 1: Butterfly Valve

Before:
ƒ Effect of minimum
cell volume:
ƒ We had used 2e-6 m3
before;
ƒ Based on the
smallest cell
dimension (3 mm),
we obtain a volume
of 4.5e-6 m3
ƒ Here we have tried
5e-6 m3 (to help
avoid the “wake” of
small cells).
Size jump
More efficient use of cells
Slide 4-14
 Local Remeshing Ex. 1: Butterfly Valve

Stretched cells near the moving wall

ƒ Effect of ideal height:
ƒ We had used 0.003 m
before, and got
excessively small cells
ƒ Here we tried 0.006 m

Before:

Size jumps

Slide 4-15
 Local Remeshing Ex. 1: Butterfly Valve

ƒ Remeshing controls
Control via min. cell volume
summary:
ƒ Use the minimum cell
volume to steer
overall size
uniformity;
ƒ Use the ideal height
to steer cell size
adjacent to the
moving wall;
ƒ We will gain more
control by using size
functions (next
lecture).

Slide 4-16 Control via ideal height

 Local Remeshing:
Short Example 1/5
ƒ Compressor with spring-
loaded intake and exhaust
valves;
ƒ Flow solution (contours of
velocity).

Slide 4-17
 Local Remeshing: Short Example 2/5
ƒ An HVAC valve:
ƒ Remeshing and
smoothing;
ƒ Nonconformal
grid interface
(circular arc);
ƒ Flow solution on
next slide.

Slide 4-18
 Local Remeshing: Short Example 3/5
ƒ Automotive
valve:
ƒ Remeshing,
smoothing, and
layering;
ƒ 4 nonconformal
grid interfaces
(vertical lines);
ƒ The gaps are
fully blocked;

Slide 4-19
 Local Remeshing: Short Example 4/5

ƒ Gear pump

Slide 4-20
 Local Remeshing: Short Example 5/5

ƒ Positive
displacement
pump

Slide 4-21
 Agenda

Overview of the Dynamic Mesh (DM) Model

Dynamic Meshing Schemes:

i. Layering for Linear Motion
ii. Spring Smoothing for Small, General Motion
iii. Local Remeshing for Large, General Motion
iv. Local Remeshing with Size Functions

UDF Macros to Govern the Dynamic Mesh:

v. Coupled Mesh Motion via the 6 DOF UDF
vi. Controlling Rigid Body Motion using
DEFINE_CG_MOTION
vii. Controlling Projection onto Deforming Boundaries using
DEFINE_GEOM
viii. Controlling the Motion of Individual Nodes using
DEFINE_GRID_MOTION
ix. Miscellaneous UDF Examples

New Features in FLUENT 6.2

Slide 0-2
V. Local Remeshing with Size
Functions

Slide 5-1
 Size Functions: Introduction

ƒ This section builds on what we have learned about local remeshing;

ƒ The purpose of size functions is to gain additional control over the marking
preceding the local remeshing;
ƒ In general, a size function is a function that starts with a small value at the
moving object’s surface, and whose value grows as we move away from the
object; it is a size distribution;
ƒ In FLUENT, we mark those cells whose size (length scale) is higher than the
local value of the size function;
ƒ Note that the size function is only used for marking cells before remeshing –
it is not used to govern the cell size during the remeshing; thus it is an
indirect control;
ƒ The overall remeshing algorithm (which we discussed before) has only one
change (shown in blue):

Slide 5-2
 Remeshing & Size Functions: Algorithm
1. At the beginning of every time step:
ƒ Mark all cells whose skewness is above “Maximum Cell Skewness”
2. If ( time = (“Size Remesh Interval”) ⋅ ∆t ) then
ƒ Mark all cells whose volume is below “Minimum Cell Volume”
or above “Maximum Cell Volume”
ƒ Mark all cells whose size is above or below the local value of the size function
3. Locally remesh only the marked cells:
ƒ “Must Improve Skewness”: remesh only if the resulting cell will be less skewed than
before (almost always selected);
ƒ Several meshing strategies are tried to arrive at the best result (marked cells are
agglomerated/fused into cavities, which are then remeshed [initialize, refine]);
4. Move the object/boundary;
5. Perform smoothing iterations (if smoothing is turned on);
6. Interpolate the solution onto the new mesh;

Slide 5-3
 Remeshing & Size Functions, Example 1:
Airdrop
ƒ Let us use the example of an airdrop of a
rescue pod;
ƒ We select “remeshing”, “sizing function”,
and “Must Improve Skewness”;
ƒ We only want to see the effect of the size
function, so we:
ƒ Set the minimum and maximum cell
volumes to extreme values, so that no
cells will be marked based on volume;
ƒ Set the maximum cell skewness very
high, so that no cells will be marked based
on skewness;
ƒ Accept the other defaults;

Slide 5-4
 Remeshing & Size Functions, Example 1:
Airdrop
ƒ The defaults work quite well overall, except for some squished cells below
and behind the pod, and except for the creation of spots of small cells;
ƒ The problem here is that as the pod draws near, those cells become marked
based on the size function; since they were originally moderately skewed, the
remeshing improves their skewness, so they end up being remeshed,
unfortunately with small cells.

Cluster of
small cells
Squished
cells

Slide 5-5
 Remeshing & Size Functions, Example 1:
Airdrop
ƒ One cannot improve the situation significantly by changing the settings for
the size function, or by changing remeshing parameters;
ƒ We can avoid the squished cells by making the influence of the pod felt at
larger distances from the pod: we turn on smoothing, with the default spring
constant of 0.05:

With
smoothing!

Slide 5-6
 Remeshing & Size Functions, Example 1:
Airdrop
ƒ Finally, let us add all of our previous experience: we keep the smoothing
(k = 0.05), but also change the remeshing controls to the best values we
had found: Vmin = 0.006 m3, Vmax = 1, maximum skewness = 0.65.
ƒ The result is good, and computes quickly! During certain time steps, one
does still see some clusters of small cells.

With size
functions!
Best
mesh
without
size
functions
Slide 5-7
 Remeshing & Size Functions: Tips, Limitations
ƒ We can even plot contours of the size function (i.e., of sizeP):
ƒ In the TUI, use solve/set/expert and then answer as shown below;
ƒ This makes available the plotting of contours of background sizing function:

Slide 5-8
 Remeshing & Size Functions: Tips, Limitations
ƒ Here is a plot of contours of the size function (i.e., of sizeP) for the airdrop:
ƒ This is a useful
debugging tool:

Slide 5-9
 Agenda

Overview of the Dynamic Mesh (DM) Model

Dynamic Meshing Schemes:

i. Layering for Linear Motion
ii. Spring Smoothing for Small, General Motion
iii. Local Remeshing for Large, General Motion
iv. Local Remeshing with Size Functions

UDF Macros to Govern the Dynamic Mesh:

v. Coupled Mesh Motion via the 6 DOF UDF
vi. Controlling Rigid Body Motion using
DEFINE_CG_MOTION
vii. Controlling Projection onto Deforming Boundaries using
DEFINE_GEOM
viii. Controlling the Motion of Individual Nodes using
DEFINE_GRID_MOTION
ix. Miscellaneous UDF Examples

New Features in FLUENT 6.2

Slide 0-2
VI. Coupled Mesh Motion via
the 6 DOF UDF

Slide 6-1
 6 DOF Coupled Motion: Introduction

ƒ So far, we have only used prescribed motion: we specified the location or

velocity of the object using the in-cylinder tool or a profile;
ƒ Now we would like to move the object as a result of the aerodynamic forces
and moments acting together with other forces, such as the force due to
gravity, thrust forces, or ejector forces (i.e., forces used to initially push
objects away from an airplane or rocket, to avoid collisions); we call this
coupled motion;
ƒ Fluent provides a UDF (user-defined function) that computes the trajectory
of an object based on the aerodynamic forces/moments, gravitational force,
and ejector forces. This is often called a 6 DOF Solver (Six Degree Of
Freedom Solver), and we refer to it as the 6 DOF UDF;
ƒ The 6 DOF UDF is fully parallelized.

Slide 6-2
 6 DOF; Example 1: Airdrop

ƒ We will learn about the 6 DOF UDF by applying it to the airdrop of the rescue pod;
ƒ Let us begin by making changes to the UDF before we compile it. The user
defines several parameters: we begin with the ID of the wall of the moving object
and with the mass and second moments in the local coordinate system:

Excerpt from the 6 DOF UDF:

/**********************************************************/
ID of the wall zone of the moving object #include "udf.h“
/**********************************************************
* 6DOF UDF
Mass of the rescue pod (15,000 kg) ***********************************************************/
#define ZONE_ID1 10 /* face ID of the moving object */
/* properties of moving object: */
#define MASS 15000.0 /* mass of object, kg */
#define IXX 1.0e+6 /* moment of inertia, Nms^2 */
#define IYY 3.0e+6 /* moment of inertia, Nms^2 */
Second moments of #define IZZ 3.0e+6 /* moment of inertia, Nms^2 */
#define IXZ 0.0 /* moment of inertia, Nms^2 */
inertia of the rescue pod #define IXY 0.0 /* moment of inertia, Nms^2 */
#define IYZ 0.0 /* moment of inertia, Nms^2 */
#define NUM_CALLS 1 /* number of times routine called
(number of moving zones) */
#define R2D 180./M_PI

Slide 6-3
 6 DOF; Example 1: Airdrop

ƒ The user continues by adjusting the ejector forces in the global coordinate system:
/****************************************************************/
* Add ejector forces
*****************************************************************/
static void
add_injector_forces (real *x_cg, real *euler_angle, real *force, real *momentum)
{
/* (needs to be updated) */
/* distances from body to ejectors (front/back) */
register real dfront = fabs (x_cg[2] - (0.179832 * euler_angle[1]));
register real dback = fabs (x_cg[2] + (0.329184 * euler_angle[1]));
Message0 ("\nfront/back distance ejectors = %g, %g", dfront, dback);

if (dfront <= 0.100584)

{
force[2] += 0.0;
In this case, momentum[1] += 0.0;
the ejector Message0 ("\nAdded front ejector force.");
}
forces and if (dback <= 0.100584)
moments {
force[2] += 0.0;
are zero momentum[1] += 0.0;
Message0 ("\nAdded back ejector force.");
}

Slide 6-4
 6 DOF; Example 1: Airdrop

ƒ Notice the Fluent-provided macro (DEFINE_CG_MOTION), which we will discuss in

the next section;
ƒ Also notice the name “six_dof”:

/*******************************************************
* Main 6DOF UDF
*******************************************************/
DEFINE_CG_MOTION(six_dof, dt, cg_vel, cg_omega, time, dtime)
/*
six_dof = name shown in Fluent GUI
dt = thread
cg_vel = old/updated cg velocity (global)
cg_omega = old/updated angular velocity (global)
time = current time
dtime = time step
*/
{
real f_glob[3]; /* Total forces (global) */

Slide 6-5
 6 DOF; Example 1: Airdrop

ƒ The user finally adjusts the gravity vector in the global coordinate system:

In this 2D case, the gravity /*

vector points into the Initialize gravity acceleration */
grav_acc[0] = 0.0;
negative y-direction grav_acc[1] = -9.81;
grav_acc[2] = 0.0;
/*
Function call to read from Read data previous time step */
read_velocities (v_old_glob, om_old_body, euler_angle);
file “velocities_3d” /*
Get CG position */
Obtain current CG for (i = 0; i < ND_ND; i++)
x_cg[i] = DT_CG(dt)[i];
location from the GUI /*
Count number of calls done */
if ((++calls) == NUM_CALLS)
last_call = TRUE;
Fluent-provided /*
Get aerodynamic forces and moments */
macro to compute the Compute_Force_And_Moment (domain, tf1, x_cg, f_glob, m_glob, TRUE);

viscous and pressure

forces and moments

Slide 6-6
 6 DOF; Example 1: Airdrop

ƒ We are done modifying the 6DOF UDF;

ƒ If desired, the user next creates an initial file “velocities_3d” using a simple text
processor;
ƒ In this case, we specify one initial nonzero angular velocity component;
ƒ Note that since the case is 2D, we only specify two linear velocity components:

Nonzero angular speed, ω z

“velocities_3d”
0.000000e+000 0.000000e+000 0.000000e+000 0.000000e+000 3.000000e-001 0.000000e+000 0.000000e+000 0.000000e+000

Linear Angular velocity Euler angles

velocity components ω x , ω y and ω z in radians
components in rad/sec and in body
vx and vy in coordinates
m/s

Slide 6-7
 6 DOF; Example 1: Airdrop

ƒ Having made the changes to the 6 DOF UDF, we are ready to hook it into
the case;
ƒ We load the case we had already set up (for which we had driven the
motion with a profile);
ƒ Then we compile the 6 DOF UDF as shown: first add the UDF
(six_dof_airdrop.c), then build a library (libudf-airdrop), and finally load
that library:

Slide 6-8
 6 DOF; Example 1: Airdrop

ƒ Next we revisit the definition of the dynamic zones, and select “six_dof” as
the UDF that drives the motion of the pod’s walls (wall-object) and the
fluid zone (fluid-bl) consisting of the quad cells in the boundary layer
adjacent to the rescue pod:

“wall-object”
“fluid-bl”

Slide 6-9
 6 DOF; Example 1: Airdrop

ƒ Even in cases with

coupled motion, it is wise
to preview the mesh
motion before carrying
out the flow calculations;
ƒ In this case, one can start
without initializing, and
the object will simply
drop under the influence
of gravity (it will also
rotate because of the
velocities_3d file that we
have supplied);
ƒ One can observe the effect
of one’s choices for the
dynamic mesh parameters
(such as the spring
constant, the maximum
skewness, etc.).
Slide 6-10
 6 DOF; Example 1: Airdrop

ƒ Finally, one can re-load the

case (to get back to the
original mesh) and compute
the flow and the coupled
motion;
ƒ The figure shows pressure
contours corresponding to a
freestream Mach number of
0.8 – note how the object has
drifted aft;
ƒ This problem exists as a
tutorial.

Slide 6-11
 6 DOF coupled motion;
short examples (1 of 4)
ƒ Store dropped from a
delta wing (NACA
64A010) at Mach 1.2;
ƒ Ejector forces
dominate for a short
time;
ƒ All-tet mesh;
ƒ Smoothing;
remeshing with size
function;
ƒ Fluent results agree
very well with wind
tunnel results!
ƒ Tutorial exists.

Slide 6-12
 6 DOF coupled motion;
short examples (2 of 4)
ƒ Projectile
moving inside
and out of a
barrel;
ƒ Initial patch in
the chamber
drives the
motion;
ƒ User-defined real
gas law (Abel-
Nobel Equation
of State);
ƒ Layering;
ƒ Tutorial exists.

Slide 6-13
 Outer Interface (3 edges)
Inner Interface (2 edges)

static
mesh
zone
Muzzle
brake
barrel
bullet
axis

static
mesh non- moving mesh zone (3 faces)
zone conformal
interface

Slide 6-14
 6 DOF coupled motion;
short examples (3 of 4)
ƒ How well do the 6DOF Final condition at shot exit
UDF and the dynamic mesh
(DM) model work?
ƒ Consider a classic problem:
the Lagrange gun;
ƒ Initial patch in the chamber
drives the motion of the
50 kg bullet/piston;
ƒ User-defined real gas law
(Abel-Nobel Equation of
State);
ƒ Layering; Initial condition at time t = 0
ƒ Superb agreement (red and
green data) all the way to
shot exit!

Slide 6-15
 Agenda

Overview of the Dynamic Mesh (DM) Model

Dynamic Meshing Schemes:

i. Layering for Linear Motion
ii. Spring Smoothing for Small, General Motion
iii. Local Remeshing for Large, General Motion
iv. Local Remeshing with Size Functions

UDF Macros to Govern the Dynamic Mesh:

v. Coupled Mesh Motion via the 6 DOF UDF
vi. Controlling Rigid Body Motion using
DEFINE_CG_MOTION
vii. Controlling Projection onto Deforming Boundaries using
DEFINE_GEOM
viii. Controlling the Motion of Individual Nodes using
DEFINE_GRID_MOTION
ix. Miscellaneous UDF Examples

New Features in FLUENT 6.2

Slide 0-2
VII. Controlling Rigid
Body Motion using
DEFINE_CG_MOTION

Slide 7-1
 DEFINE_CG_MOTION : Introduction

ƒ In the previous lecture, we used the 6DOF UDF to couple the motion of
objects to the flow solution;
ƒ We saw that the heart of the 6DOF UDF is the DEFINE_CG_MOTION macro;
ƒ The macro simply governs how far the object will move/rotate during each time step
(it is called every time step);
ƒ The object moves as a rigid body: all nodes and boundaries/walls associated with it
move as one, without any relative motion (deformation);
ƒ The translational and rotational motions of the rigid body are specified with respect to
the CG (Center of Gravity) of the body;
ƒ The macro works for both prescribed and coupled motions.

Slide 7-2
 DEFINE_CG_MOTION;
Example 1: Airdrop

ƒ Let us revisit the airdrop of the

rescue pod – at one point we
prescribed the rigid body motion by
means of a profile;
ƒ Let us repeat the same example, but
use a UDF instead;
ƒ The horizontal velocity component
will be zero, while the vertical one
will rise linearly and then stay
constant at –1 m/s. We will also use
a constant rotation of 0.3 rad/sec;

Slide 7-3
 DEFINE_CG_MOTION;
Example 1: Airdrop

This is the complete UDF:

#include "udf.h“
#define ZONE_ID1 3 /* face ID of the moving object */
DEFINE_CG_MOTION(pod_prescribed_UDF, dt, cg_vel, cg_omega, time, dtime)
{
cg_vel[0] = 0.0;
dt = dynamic thread
if (time <= 3.0)
cg_vel[1] = - time/3.0;
pointer
else
cg_vel[1] = - 1.0;
cg_omega[0] = 0.0; Note this name
cg_omega[1] = 0.0;
cg_omega[2] = 0.3;
}

Slide 7-4
 DEFINE_CG_MOTION;
Example 1: Airdrop

ƒ We hook the UDF in and preview

the motion (250 time steps of 0.03
seconds each)

Slide 7-5
 DEFINE_CG_MOTION; Example 2: Pump

ƒ This piston pump is a

bent-axis pump
because the
reciprocating piston is
driven by a thrust
plate whose axis is
bent with respect to
the axis of the
reciprocating motion;
ƒ Observe that the
cylinder rotates and
reciprocates.

Slide 7-6
 DEFINE_CG_MOTION; Example 2: Pump
rot_int (the circular
ƒ The figure shows the labels wall and rot_fluid cap on the cylinder)
for the different zones;
ƒ The cylinder rotates, so that
rot_int slides over stat_int;
ƒ rot_int and stat_int form a
nonconformal grid interface; rot-wall-bot stat_int
ƒ The cylinder rotates because
we define rot_fluid as a moving
zone (SMM, sliding mesh
wall:001
method) with a rotational speed
of 10 RPM about the z-axis
(see next slide) inlet

Slide 7-7
 DEFINE_CG_MOTION; Example 2: Pump
ƒ The bottom figure shows how we cause
the cylinder to rotate;
ƒ In addition, we cause the cylinder to
reciprocate by moving the piston face
rot_wall_bot as a rigid body – also see
the UDF on the next slide.

Slide 7-8
 DEFINE_CG_MOTION; Example 2: Pump
No space !
ƒ The UDF
#include "udf.h“
prescribes the DEFINE_CG_MOTION(piston, dt, vel, omega, time, dtime)
rigid body {
motion of the real A=2.0; /*Amplitude of sine oscillation with period T*/
piston face as a real n=10.0; /*rpm of pump*/
sinusoidal real phi=-45.0; /*phase offset*/
function of phi=phi*M_PI/180;
time; /* set z-component of velocity */
vel[0] = 0.0;
vel[1] = 0.0;
vel[2] = 2.0*M_PI*n*A/60.0*cos(2.0*M_PI*n*time/60.0-phi);
omega[0] = 0.0;
omega[1] = 0.0;
omega[2] = 0.0;
}
Slide 7-9
 DEFINE_CG_MOTION; Example 2: Pump
ƒ The physical piston is
driven by connecting
rods that are
connected to a thrust
plate (wobble plate)
that acts like a
camshaft;
ƒ This example has
demonstrated how to
combine the dynamic
mesh (DM) model
with the sliding mesh
model (SMM).

Slide 7-10
VIII: Controlling Projection onto
Deforming Boundaries using
DEFINE_GEOM

Slide 8-1
 DEFINE_GEOM : Introduction

ƒ This macro allows us to define geometry that we can project the boundary
nodes of a mesh onto. It is used in conjunction with deforming boundary
zones;
ƒ We had previously projected the boundary nodes of a mesh onto a circular
cylinder; only the circular cylinder and the plane are available through the
GUI; for more complex geometry, one must use this macro;
ƒ Such a projection allows the nodes to slide along the walls of the physical
object, or along other boundary zones – we had called such zones deforming
boundary zones, or simply deforming zones;
ƒ We also refer to the sliding of the nodes on these deforming zones as the
repositioning of nodes;

Slide 8-2
 DEFINE_GEOM; Example 1:
Butterfly Valve

ƒ Let us revisit the butterfly

valve to learn how to apply
DEFINE_GEOM;
ƒ Could we turn the curved
housing into a deforming
boundary zone?
ƒ Yes, but only by using
DEFINE_GEOM since we
may not point the axis of the
cylinder that is available via
the GUI into the page;

Slide 8-3
 DEFINE_GEOM; Example 1:
Butterfly Valve
Best result without
ƒ The problem had been that the sizing functions
(Slide 4-19)
clustered cells on the housing could
not follow the motion of the valve;
ƒ Let us now allow them to slide
along the arcs;
ƒ The equation of the circular housing
is:
Best result with
x +y =R
2 2 2
sizing functions
(Slide 5-14)

ƒ Or:

y = r 2 − x2

Slide 8-4
 DEFINE_GEOM; Example 1:
Butterfly Valve

ƒ Here is the #include "udf.h"

complete UDF! #define R 0.109

DEFINE_GEOM(slippery_arcs, domain, dt, position)

{
real y;

y = position[1];

if (y >= 0.0)
position[1] = sqrt(R*R - position[0]*position[0]);
y = r 2 − x2 else
position[1] = - sqrt(R*R - position[0]*position[0]);
}

Slide 8-5
 DEFINE_GEOM; Example 1:
Butterfly Valve

ƒ Details of the setup for the

deforming/slippery zone “wall-circular-
housing” are shown:
ƒ The result would remain the same if we
would turn on “Remeshing” here as well,
because this regional remeshing would
only happen if the deforming/slippery zone
would be touched by the moving zone
(“wall-butterfly” in this case).

Slide 8-6
 DEFINE_GEOM; Example 1:
Butterfly Valve

ƒ If we do not use sizing

functions, the result is as Sparse
shown; region
ƒ We note that the boundary
nodes have moved along
with the valve until it
reached the corner, as
desired;
ƒ But they get stuck at the
corner, with the rest of the
arc being sparsely meshed;
ƒ The mesh also looks Clustered
skewed in general, so let cells at
us use sizing functions. corner

Slide 8-7
 DEFINE_GEOM; Example 1:
Butterfly Valve

ƒ Once we turn on the sizing functions, the

result is as shown;
ƒ We have eliminated the sparse regions;
ƒ The clusters near
two of the corners
remain;
ƒ The clusters can be
slightly improved
by decreasing the
boundary node
relaxation from
one to 0.5.

Slide 8-8
 DEFINE_GEOM; Example 1:
Butterfly Valve

ƒ Here is the
animation
(320 frames at
0.005 seconds
each);
ƒ Note how the
nodes slide
along the
housing.

Slide 8-9
IX: Controlling the Motion of
Individual Nodes using
DEFINE_GRID_MOTION

Slide 9-1
 DEFINE_GRID_MOTION : Introduction

ƒ This macro allows us to move any nodes belonging to the fluid zones or to the
boundary zones;
ƒ The macro offers the maximum level of control over the deforming mesh;
ƒ One is able to combine rigid body motion, deformations, and relative motions,
and one may use projection zones at the same time;
ƒ The macro is called every time step;

Slide 9-2
 DEFINE_GRID_MOTION; Example 1:
Compliant Wing Profile
ƒ In this example, we
sinusoidally (in time
and space) change the
shape of a small
portion of the top
skin, just aft of the
rounded leading edge;
ƒ This is a fluid-
structures interaction
(FSI) problem;

Slide 9-3
 DEFINE_GRID_MOTION; Example 1:
Compliant Wing Profile
ƒ This image shows the
location of the skin “wall-compliant”
segment that will be
moved – it is called
“wall-compliant”, and
is shown in red;

Slide 9-4
 DEFINE_GRID_MOTION; Example 1:
Compliant Wing Profile
ƒ Here we are setting up the
dynamic zone;
ƒ As the wall section moves,
the all-quad mesh adjacent
to it will be smoothed, so
we specify spring
smoothing as the dynamic
mesh scheme (we also
need to use an rpsetvar).

Slide 9-5
 DEFINE_GRID_MOTION; Example 1:
Compliant Wing Profile
ƒ As the wall
section
moves, the
all-quad mesh
adjacent to it
is smoothed;
ƒ The spring
constant was
0.5

Slide 9-6
 DEFINE_GRID_MOTION; Example 1:
Compliant Wing Profile
#include "udf.h"
ƒ So what does #define L 0.4 /* Length of the compliant strip (m) */
the UDF look #define NUM_PERIODS 20 /* Number of bumps in the surface */
like? #define AMP 0.00070 /* Amplitude (meters) */
#define ORIGINCX 0.08 /* Coordinates of the upstream end */
ƒ This UDF is a #define ORIGINCY 0.08 /* of the compliant strip */
bit trickier; #define FREQ 1000.0 /* Frequency in Hertz (cycle/sec) */
ƒ We need to
show it over DEFINE_GRID_MOTION(compliant, domain, dt, time, dtime)
several slides: {
Thread *tf = DT_THREAD (dt);
face_t f;
Node *node_p;
real X_TILD, X_TILD_STAR, Y_TILD;
real A;
int n;
Slide 9-7
 DEFINE_GRID_MOTION; Example 1:
Compliant Wing Profile
/* Set/activate the deforming flag on adjacent cell zone, which */
ƒ Page 2 (of 4) /* means that the cells adjacent to the deforming wall will also be */
of the UDF: /* deformed, in order to avoid skewness. */

SET_DEFORMING_THREAD_FLAG (THREAD_T0 (tf));

/* Compute the amplitude as a function of time: */

A = AMP * sin (2.0 * M_PI * FREQ * time);

Slide 9-8
 DEFINE_GRID_MOTION; Example 1:
Compliant Wing Profile
/* Loop over the deforming boundary zone's faces; */
/* inner loop loops over all nodes of a given face; */
ƒ Page 3 (of 4)
of the UDF: begin_f_loop (f, tf)
{
f_node_loop (f, tf, n)
{
node_p = F_NODE (f, tf, n);

/* Update the current node only if it has not been previously visited: */

if (NODE_POS_NEED_UPDATE (node_p))

Slide 9-9
 DEFINE_GRID_MOTION; Example 1:
Compliant Wing Profile
/* Set flag to indicate that the current node's */
/* position has been updated, so that it will not be */
ƒ Page 4
/* updated during a future pass through the loop: */
(of 4) of
the UDF: NODE_POS_UPDATED (node_p);
X_TILD = NODE_X (node_p) - ORIGINCX;
New y- X_TILD_STAR = NUM_PERIODS *2.0* M_PI * X_TILD /L;
position of Y_TILD = A * ( 1.0 + sin (X_TILD_STAR - 0.5 * M_PI) );
node_p NODE_Y (node_p) = Y_TILD + ORIGINCY;
} /* end if */
} /* end node loop */
} /* end face loop */
end_f_loop (f, tf);
}
/* End */
Slide 9-10
 DEFINE_GRID_MOTION; Example 1:
Compliant Wing Profile
ƒ Here is the
animation
again;
ƒ As the wall
section moves,
the all-quad
mesh adjacent
to it is
smoothed;
ƒ In this example,
we only moved
the nodes on a
wall zone;

Slide 9-11
DEFINE_GRID_MOTION:
Fly with Beating Wings

Slide 9-12
 Agenda

Overview of the Dynamic Mesh (DM) Model

Dynamic Meshing Schemes:

i. Layering for Linear Motion
ii. Spring Smoothing for Small, General Motion
iii. Local Remeshing for Large, General Motion
iv. Local Remeshing with Size Functions

UDF Macros to Govern the Dynamic Mesh:

v. Coupled Mesh Motion via the 6 DOF UDF
vi. Controlling Rigid Body Motion using
DEFINE_CG_MOTION
vii. Controlling Projection onto Deforming Boundaries using
DEFINE_GEOM
viii. Controlling the Motion of Individual Nodes using
DEFINE_GRID_MOTION
ix. Miscellaneous UDF Examples

New Features in FLUENT 6.2

Slide 0-2
X. Miscellaneous Dynamic Mesh
UDF Examples

Slide 10-1
 UDF Example:
Valve with Membrane
ƒ Let us study the set-
up for a problem that
involves a butterfly
valve and a flexible
membrane;
ƒ We use three UDFs:
1. CG_MOTION to
spin the valve
2. CG_GEOM for
projecting the
topmost nodes onto
the horizontal top
wall
3. GRID_MOTION
to move the
membrane

Slide 10-2
 UDF Examples:
Valve with Membrane
#include "udf.h“
#define omega 1.0 /* rotational speed, rad/sec */
#define R 0.109 /* radius of the arc, meters */
DEFINE_CG_MOTION(butterfly_flex_UDF, dt, cg_vel, cg_omega, time, dtime)
{
cg_vel[0] = 0.0;
ƒ Here is a cg_vel[1] = 0.0;
listing of the cg_vel[2] = 0.0;
Valve
combined cg_omega[0] = 0.0; rotation
UDF cg_omega[1] = 0.0;
cg_omega[2] = omega;
(Slide 1 of 3): }

DEFINE_GEOM(plane, domain, dt, position)

{ Projection onto the
position[1] = R;
horizontal top wall
}

Slide 10-3
 UDF Examples:
Valve with Membrane

DEFINE_GRID_MOTION(moving_arc, domain, dt, time, dtime)

{
ƒ Listing of the Thread *tf = DT_THREAD (dt);
combined face_t f;
UDF Node *node_p;
real alpha, theta, x, ymag, yfull, y; Flexing
(Slide 2 of 3): membrane
int n;
SET_DEFORMING_THREAD_FLAG (THREAD_T0 (tf));
alpha = omega * CURRENT_TIME;
theta = 2.0 * alpha + 3.0 * M_PI / 2.0;

Slide 10-4
 UDF Examples:
Valve with Membrane
begin_f_loop (f, tf)
{
f_node_loop (f, tf, n)
{
ƒ Listing of the node_p = F_NODE (f, tf, n);
if (NODE_POS_NEED_UPDATE (node_p))
combined {
UDF NODE_POS_UPDATED (node_p);
(Slide 3 of 3): x = NODE_X (node_p); Flexing
ymag = sqrt (R*R - x*x) + 0.03; membrane
yfull = ymag - 0.1;
y = - 0.1 + yfull * sin(theta);
NODE_Y (node_p) = y;
}
}
}
end_f_loop (f, tf);
}

Slide 10-5
 UDF Examples:
Valve with Membrane
ƒ Here is the animation
again;
ƒ The motions of the
valve and the
membrane are
synchronized;
ƒ Smoothing and
remeshing with size
functions were used;
ƒ The preview
consisted of 626 time
steps of 0.005 sec
each.
ƒ Applications:
biomed, synthetic
jets, etc.
Slide 10-6
 Agenda

Overview of the Dynamic Mesh (DM) Model

Dynamic Meshing Schemes:

i. Layering for Linear Motion
ii. Spring Smoothing for Small, General Motion
iii. Local Remeshing for Large, General Motion
iv. Local Remeshing with Size Functions

UDF Macros to Govern the Dynamic Mesh:

v. Coupled Mesh Motion via the 6 DOF UDF
vi. Controlling Rigid Body Motion using
DEFINE_CG_MOTION
vii. Controlling Projection onto Deforming Boundaries using
DEFINE_GEOM
viii. Controlling the Motion of Individual Nodes using
DEFINE_GRID_MOTION
ix. Miscellaneous UDF Examples

New Features in FLUENT 6.2

Slide 0-2
XI. New Dynamic Mesh Features in
FLUENT 6.2

Slide 11-1
New Dynamic Mesh Features in FLUENT 6.2:
2.5 D Remeshing/Smoothing

ƒ For mapable (2.5D; extruded) geometries in particular pumps

Slide 11-2
New Dynamic Mesh Features in FLUENT 6.2:
Boundary Region Remeshing (Slide 1 of 2)

In FLUENT 6.1 we had the

following restrictions:

– Single zone
– Closed loop

Slide 11-3
New Dynamic Mesh Features in FLUENT 6.2:
Boundary Region Remeshing (Slide 2 of 2)

ƒ New in FLUENT 6.2:

ƒ Symmetric boundaries
ƒ Across multiple zones
ƒ Feature preservation (e.g.,
corners are preserved)
ƒ Non-closed loops

Slide 11-4
New Dynamic Mesh Features in FLUENT 6.2:
Remeshing/Smoothing with Dynamic Adaption

Limitation:
Dynamic
adaption
cannot be used
in conjunction
with layering
or with
boundary
remeshing

Slide 11-5
New Dynamic Mesh Features in FLUENT 6.2:
Layering at Periodics

Slide 11-6
New Dynamic Mesh Features in FLUENT 6.2:
Full Compatibility with VOF

Note: The DM is now fully compatible with ALL multiphase models

Slide 11-7
 New Dynamic Mesh Features in FLUENT 6.2:
6-DOF Solver
ƒ 6-DOF solver now built into the GUI
ƒ GUI panels still do not provide for constraints (such as hinges), but
constrained motion is possible via UDF;
ƒ The dynamic mesh UDFs contain hooks for load forces/moments;
ƒ Transformations can be customized (although we use a transformation
between local and global coordinate systems that is widely used in the
aerospace and shipbuilding industries)

Slide 11-8
 New Dynamic Mesh Features in FLUENT 6.2:
Dynamic Mesh Events
ƒ Events based on time (not just based on the crank angle as before), and
without having to use the in-cylinder tools (where they were called in-
cylinder events);
ƒ New events:
ƒ Activate/Deactivate cell zones
ƒ Change URF

Slide 11-9
 New Dynamic Mesh Features in FLUENT 6.2:
Miscellaneous
ƒ Improved parallel performance, in particular IC
ƒ Reduced number of cell migrations during mesh update
ƒ Encapsulation of non-conformals not required anymore
ƒ Zone motion preview
ƒ Motion history for 6-DOF applications

Slide 11-10
FLUENT 6.2: Sneak Preview

Slide 11-11
FLUENT 6.2: Sneak Preview

Slide 11-12
FLUENT 6.2: Sneak Preview

Slide 11-13
 How to obtain support for using the
Dynamic Mesh (DM) model
• Study the manuals;
• Work through the dynamic mesh tutorials;
• Attend Fluent’s advanced training on the dynamic mesh;
• Search the Solutions using the Online Technical Support
(OTS) at www.fluentusers.com ;
• Create a case using the Online Technical Support (OTS) at
www.fluentusers.com ; the case will be answered by
Fluent’s support staff, and your support engineer may
contact the dynamic mesh developers if difficulties arise;
• If the problem is particularly intimidating, consider having
Fluent’s Consulting Team develop a prototype for you

Slide 0-3
 Purpose of this session

• Show you how to use the controls for the Dynamic Mesh
(DM) model, based on a few examples

• Show you how to write simple UDFs that control the

dynamic zones, based on a few examples

• Show you the new features in FLUENT 6.2

• To have the examples motivate you – what application

might you use the model for ?

Questions?

Slide 0-4
Dynamic Mesh Case Studies
(FLUENT 6.1)
Christoph Hiemcke
9 June 2004

Thank you for

your attention!