Dynamic Mesh

(1)

Dynamic Mesh Case Studies

(FLUENT 6.1)

Christoph Hiemcke

9 June 2004

(2)

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 ?

(3)

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

(4)

I. Overview of the Dynamic Mesh

(DM) Model

(5)

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

(6)

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

(7)

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

(8)

(9)

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.

(10)

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):

Piston wall moves

Complex geometry near cylinder head is tri meshed

(11)

Layering Example 1: Piston

Cells are being split or collapsed as the piston wall comes near (explanation on the next page):

(12)

Layering Example 1: Piston

Split if:

Collapse if:

h_ideal is defined later,

during the definition of the dynamic zones. ideal S h h > (1+

α

) ideal ch h <

α

(13)

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 domains (e.g. cylindrical geometry).

Initially, piston at bottom-most position Piston at top-most position Edge “i”

Edges “i” and “i+1” have same shape Edge “i+1” is an average of edge “i” and the piston shape Constant Height Constant Ratio

(14)

Layering Example 1: Piston

Definition of the dynamic zone:

(15)

Layering Example 1: Piston

Definition of the ideal height of a cell layer; h_ideal is about the same

as the height of a typical cell in the model.

(16)

Layering Example 2: Conveyor Belt

A box on a conveyor belt moves through a curing oven;

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. Oven interior box Hot air Cool exterior Dynamic zone Static zone Grid interface

(17)

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.

(18)

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).

Dynamic zone Static zone

Faces are disconnected here at the interface!

(19)

Layering Example 2: Conveyor Belt

Dynamic Mesh Parameters:

Layering enabled;

“Constant Height” option (explained before);

Set up split and collapse factors (explained before).

(20)

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 moved as a rigid body at constant speed; Similarly, the box walls move as rigid bodies

as well (otherwise the velocity boundary conditions will not be correct).

((oven 2 point)

(time 0 15.0)

(v_x 1.0 1.0)

)

x-velocity (m/s) Time (sec) 1.0 FLUENT profile:

(21)

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

(22)

Layering Example 2: Conveyor Belt

Geometry of the non-conformal, sliding grid interface:

interface-top (three line segments) interface-bottom (single line segment) fluid-moving fluid-static

(23)

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;

(24)

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”.

Cell creation at stationary

edge “inlet-left-bottom” Cell destruction at stationary _{edge “outlet-right-bottom”} “fluid-moving”

(25)

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.

(26)

Layering Example 2: Conveyor Belt

(27)

Layering: Further Examples

Fuel injector;

(28)

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

(32)

Agenda

Overview of the Dynamic Mesh (DM) Model Dynamic Meshing Schemes:

ii. Spring Smoothing for Small, General Motion

iii. Local Remeshing for Large, General Motion iv. Local Remeshing with Size Functions

DEFINE_CG_MOTION

(33)

III. Spring Smoothing for

Small, General Motion

(34)

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.

(35)

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

(36)

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.

(37)

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?

(38)

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

(39)

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:

“walls-vertical”

x y

R 0.15

Cylinder walls (used for projection)

(40)

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

(41)

Spring Smoothing Ex. 1: Irregular piston

Everything OK!

One can also project onto planes or user-defined

edges/surfaces.

Note how these nodes move

(42)

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.

Spring Smoothing Ex. 1: Irregular Piston

(43)

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.

Spring Smoothing Ex. 1: Irregular Piston

(44)

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.

Spring Smoothing Ex. 1: Irregular Piston

(45)

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 of adjacent interior nodes, , affects the

b

xr

(46)

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.

Spring Smoothing Ex. 1: Irregular Piston

(47)

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.

Spring Smoothing Ex. 1: Irregular Piston

(48)

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.

Spring Smoothing Ex. 1: Irregular Piston

(49)

Agenda

ii. Spring Smoothing for Small, General Motion

iii. Local Remeshing for Large, General Motion

iv. Local Remeshing with Size Functions

DEFINE_CG_MOTION

(50)

IV. Local Remeshing for

Large, General Motion

(51)

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

(52)

Local Remeshing: Algorithm

1. At the beginning of every time step: Mark all cells whose skewness is

2. If ( time = (“Size Remesh Interval”) ) 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);

above “Maximum Cell Skewness”

t ∆ ⋅

(53)

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:

(54)

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

(55)

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

(56)

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) ) Time (sec) 3.2 1.571 0.0 Omega_z (rad/s)

The valve first rotates

CCW through 90 degrees, then CW;

The maximum

rotational speed is

(57)

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.

(58)

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; h_ideal controls the cell size adjacent

(59)

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 s m m v s t 0.018 / 16 . 0 003 . 0 = = ∆ = ∆

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)

(60)

Local Remeshing Ex. 1: Butterfly Valve

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

(61)

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

(62)

Local Remeshing Ex. 1: Butterfly Valve

We are wasting too many cells in the “wake” of the valve

Let us revisit the dynamic mesh parameters and zones

Large cells adjacent to the coarsely meshed part of the housing

(63)

Local Remeshing Ex. 1: Butterfly Valve

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).

Before:

More efficient use of cells Size jump

(64)

Local Remeshing Ex. 1: Butterfly Valve

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

(65)

Local Remeshing Ex. 1: Butterfly Valve

Remeshing controls 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).

Control via min. cell volume

(66)

Local Remeshing:

Short Example 1/5

Compressor with spring-loaded intake and exhaust valves;

Flow solution (contours of velocity).

(67)

Local Remeshing: Short Example 2/5

An HVAC valve: Remeshing and smoothing; Nonconformal grid interface (circular arc); Flow solution on next slide.

(68)

Local Remeshing: Short Example 3/5

Automotive valve: Remeshing, smoothing, and layering; 4 nonconformal grid interfaces (vertical lines); The gaps are

(69)

Local Remeshing: Short Example 4/5

(70)

Local Remeshing: Short Example 5/5

Positive

displacement pump

(71)

Agenda

ii. Spring Smoothing for Small, General Motion iii. Local Remeshing for Large, General Motion

iv. Local Remeshing with Size Functions

DEFINE_CG_MOTION

(72)

V. Local Remeshing with Size

Functions

(73)

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):

(74)

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”) ) 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);

t ∆ ⋅

(75)

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;

Remeshing & Size Functions, Example 1:

Airdrop

(76)

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

(77)

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!

(78)

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: V_min = 0.006 m3_{, V}

max = 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.

Best mesh without size With size functions!

(79)

We can even plot contours of the size function (i.e., of size_P):

In the TUI, use solve/set/expert and then answer as shown below;

This makes available the plotting of contours of background sizing function:

(80)

Here is a plot of contours of the size function (i.e., of size_P) for the airdrop:

Remeshing & Size Functions: Tips, Limitations

This is a useful debugging tool:

(81)

Agenda

v. Coupled Mesh Motion via the 6 DOF UDF

vi. Controlling Rigid Body Motion using DEFINE_CG_MOTION

(82)

VI. Coupled Mesh Motion via

the 6 DOF UDF

(83)

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.

(84)

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:

/**********************************************************/

#include "udf.h“

/********************************************************** * 6DOF UDF

***********************************************************/

#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 */

#define IZZ 3.0e+6 /* moment of inertia, Nms^2 */

#define IXZ 0.0 /* moment of inertia, Nms^2 */

#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

ID of the wall zone of the moving object

Excerpt from the 6 DOF UDF:

Mass of the rescue pod (15,000 kg)

Second moments of inertia of the rescue pod

(85)

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; momentum[1] += 0.0;

Message0 ("\nAdded front ejector force."); }

if (dback <= 0.100584) {

force[2] += 0.0; momentum[1] += 0.0;

Message0 ("\nAdded back ejector force."); } } In this case, the ejector forces and moments are zero

(86)

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 */

{

(87)

6 DOF; Example 1: Airdrop

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

/*

Initialize gravity acceleration */

grav_acc[0] = 0.0; grav_acc[1] = -9.81; grav_acc[2] = 0.0;

/*

Read data previous time step */

read_velocities (v_old_glob, om_old_body, euler_angle);

/*

Get CG position */

for (i = 0; i < ND_ND; i++) x_cg[i] = DT_CG(dt)[i];

/*

Count number of calls done */

if ((++calls) == NUM_CALLS) last_call = TRUE;

/*

Get aerodynamic forces and moments */

Compute_Force_And_Moment (domain, tf1, x_cg, f_glob, m_glob, TRUE);

In this 2D case, the gravity vector points into the negative y-direction Function call to read from

file “velocities_3d” Obtain current CG location from the GUI

Fluent-provided macro to compute the viscous and pressure forces and moments

(88)

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:

0.000000e+000 0.000000e+000 0.000000e+000 0.000000e+000 3.000000e-0010.000000e+000 0.000000e+000 0.000000e+000

Linear velocity components v_x and v_yin m/s “velocities_3d” Angular velocity components , and

in rad/sec and in body coordinates

Euler angles in radians Nonzero angular speed, ω_z

x

(89)

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:

(90)

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:

“fluid-bl”

(91)

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.).

(92)

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.

(93)

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!

(94)

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);

(95)

Outer Interface (3 edges) bullet barrel Muzzle brake axis

moving mesh zone (3 faces) static

mesh

zone conformal non-interface

static mesh zone

(96)

6 DOF coupled motion;

short examples (3 of 4)

How well do the 6DOF 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;

Superb agreement (red and green data) all the way to shot exit!

Initial condition at time t = 0

(97)

Agenda

v. Coupled Mesh Motion via the 6 DOF UDF

vi. Controlling Rigid Body Motion using DEFINE_CG_MOTION

(98)

VII. Controlling Rigid

Body Motion using

(99)

We hook the UDF in and preview the motion (250 time steps of 0.03 seconds each)

(103)

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.

(104)

DEFINE_CG_MOTION; Example 2: Pump

The figure shows the labels 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; The cylinder rotates because

we define rot_fluid as a moving zone (SMM, sliding mesh

method) with a rotational speed of 10 RPM about the z-axis (see next slide)

wall and rot_fluid

inlet stat_int

rot_int (the circular

cap on the cylinder)

wall:001 rot-wall-bot

(105)

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

(106)

DEFINE_CG_MOTION; Example 2: Pump

The UDF prescribes the rigid body motion of the piston face as a sinusoidal function of time; #include "udf.h“

DEFINE_CG_MOTION(piston, dt, vel, omega, time, dtime) {

real A=2.0; /*Amplitude of sine oscillation with period T*/

real n=10.0; /*rpm of pump*/

real phi=-45.0; /*phase offset*/

phi=phi*M_PI/180;

/* 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;

No space !

(107)

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).

(108)

VIII: Controlling Projection onto

Deforming Boundaries using

(109)

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;

(110)

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;

(111)

DEFINE_GEOM; Example 1:

Butterfly Valve

The problem had been that the

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: Or: 2 2 2

_y

_R

x

+

=

2 2

_x

r

y

=

−

Best result without sizing functions

(Slide 4-19)

Best result with sizing functions

(112)

DEFINE_GEOM; Example 1:

Butterfly Valve

Here is the complete UDF! #include "udf.h" #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]); else position[1] = - sqrt(R*R - position[0]*position[0]); } 2 2

_x

r

y

=

−

(113)

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

(114)

DEFINE_GEOM; Example 1:

Butterfly Valve

If we do not use sizing functions, the result is as shown;

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

skewed in general, so let

Clustered cells at

corner Sparse

(115)

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.

(116)

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.

(117)

IX: Controlling the Motion of

Individual Nodes using

(118)

DEFINE_GRID_MOTION : Introduction

This macro allows us to move any nodes belonging to the fluid zones or to the boundary zones;

So what does the UDF look like? This UDF is a bit trickier; We need to show it over several slides: #include "udf.h"

#define L 0.4 /* Length of the compliant strip (m) */

#define NUM_PERIODS 20 /* Number of bumps in the surface */

#define AMP 0.00070 /* Amplitude (meters) */

#define ORIGINCX 0.08 /* Coordinates of the upstream end */

#define ORIGINCY 0.08 /* of the compliant strip */

#define FREQ 1000.0 /* Frequency in Hertz (cycle/sec) */

DEFINE_GRID_MOTION(compliant, domain, dt, time, dtime) {

Thread *tf = DT_THREAD (dt); face_t f;

Node *node_p;

real X_TILD, X_TILD_STAR, Y_TILD; real A;

(124)

DEFINE_GRID_MOTION; Example 1:

Compliant Wing Profile

Page 2 (of 4) of the UDF:

/* Set/activate the deforming flag on adjacent cell zone, which */ /* means that the cells adjacent to the deforming wall will also be */ /* deformed, in order to avoid skewness. */

SET_DEFORMING_THREAD_FLAG (THREAD_T0 (tf));

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

(125)

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; */

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)) {

(126)

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 */ /* updated during a future pass through the loop: */

NODE_POS_UPDATED (node_p);

X_TILD = NODE_X (node_p) - ORIGINCX;

X_TILD_STAR = NUM_PERIODS *2.0* M_PI * X_TILD /L; Y_TILD = A * ( 1.0 + sin (X_TILD_STAR - 0.5 * M_PI) ); NODE_Y (node_p) = Y_TILD + ORIGINCY;

} /* end if */

} /* end node loop */

} /* end face loop */

end_f_loop (f, tf); }

New y-position of

(127)

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;

(128)

DEFINE_GRID_MOTION:

Fly with Beating Wings

(129)

Agenda

DEFINE_CG_MOTION

(130)

X. Miscellaneous Dynamic Mesh

UDF Examples

(131)

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

(132)

UDF Examples:

Valve with Membrane

Here is a listing of the combined UDF (Slide 1 of 3): #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; cg_vel[1] = 0.0; cg_vel[2] = 0.0; cg_omega[0] = 0.0; cg_omega[1] = 0.0; cg_omega[2] = omega; }

DEFINE_GEOM(plane, domain, dt, position) {

position[1] = R; }

Projection onto the horizontal top wall Valve

(133)

UDF Examples:

Valve with Membrane

Listing of the combined UDF (Slide 2 of 3):

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

Thread *tf = DT_THREAD (dt); face_t f;

Node *node_p;

real alpha, theta, x, ymag, yfull, y; int n;

SET_DEFORMING_THREAD_FLAG (THREAD_T0 (tf)); alpha = omega * CURRENT_TIME;

theta = 2.0 * alpha + 3.0 * M_PI / 2.0;

Flexing membrane

(134)

UDF Examples:

Valve with Membrane

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

(135)

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.

(136)

Agenda

DEFINE_CG_MOTION

(137)

XI. New Dynamic Mesh Features in

FLUENT 6.2

(138)

New Dynamic Mesh Features in FLUENT 6.2:

2.5 D Remeshing/Smoothing

(139)

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

(140)

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

(141)

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

(142)

New Dynamic Mesh Features in FLUENT 6.2:

Layering at Periodics

(143)

New Dynamic Mesh Features in FLUENT 6.2:

Full Compatibility with VOF

(144)

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)

(145)

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 cylinder tools (where they were called in-cylinder events);

New events:

Activate/Deactivate cell zones Change URF

(146)

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

(147)

(148)

(149)

(150)

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

(151)

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 ?