41658132 Dynamic Mesh

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 Motionii. Spring Smoothing for Small, General Motioniii. Local Remeshing for Large, General Motioniv. Local Remeshing with Size Functions

UDF Macros to Govern the Dynamic Mesh:v. Coupled Mesh Motion via the 6 DOF UDFvi. Controlling Rigid Body Motion using

DEFINE_CG_MOTIONvii. Controlling Projection onto Deforming Boundaries using

DEFINE_GEOM viii. Controlling the Motion of Individual Nodes using

DEFINE_GRID_MOTIONix. 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 moveboundaries and/or objects, and to adjust the mesh accordingly

Examples:Automotive piston moving inside a cylinderA flap moving on an airplane wingA valve opening and closingAn 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 inflatedAn arterial wall responding to the pressure pulse from the heartA solid propellant retreating as it is being consumed by the flameThe 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:

LayeringSpring SmoothingLocal 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: PistonFor 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

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: PistonSplit if: Collapse if:

hideal is defined later, during the definition of the dynamic zones.

idealS hh )1( α+>

idealchh α<

Slide 2-5

Layering Example 1: PistonConstant 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

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

Slide 2-9


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


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!

Slide 2-11


Dynamic Mesh Parameters:Layering enabled;“Constant Height” option (explained before);Set up split and collapse factors (explained before).

Slide 2-12


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 bodiesas 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

0.0 15.0

FLUENT profile:

Slide 2-13


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

Slide 2-14


Geometry of the non-conformal, sliding grid interface:

interface-top (three line segments)

interface-bottom (single line segment)

fluid-moving

fluid-static

Slide 2-15


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


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”

Slide 2-17


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 mAn old layer is removed once it shrinks to smaller than 0.4 * 0.1 = 0.04 mLet’s look at the motion again.

Slide 2-18


Let’s look at the motion again:

Slide 2-19

Layering: Further Examples

Fuel injector;Flow solution on the next slide.

Slide 2-20


Fuel injector;Flow solution (velocity contours).

Slide 2-21


2-stroke engine;Layering.

Slide 2-22

Premixed combustion (temperature contours)


Vibromixer;Layering;Flow solution on next slide.

Slide 2-23


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

Slide 2-24

Agenda








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 pistonThe bottom wall (“piston”) moves up and down;Motion is via “in-cylinder” toolSmoothing uses default parameters in this case.

piston

Slide 3-4

Spring Smoothing Ex. 1: Irregular pistonThe 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


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

yR 0.15

Cylinder walls (used for projection)

Slide 3-7


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


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

Note how these nodes move

Slide 3-9

What happens if we change the spring constant, k ?We saw what happens with the default value:

k = 1The effect of the moving wall is felt mostly near the moving wall, but not at larger distances.

Spring Smoothing Ex. 1: Irregular Piston

k = 1

Slide 3-10

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

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

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 position of nodes, , on the deforming boundary wall:


adjnb

nb xxx rrr

∆+=+ β1

adjxr∆bxr

Slide 3-13

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

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

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








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 andgeneral (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 skewnessand/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

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

Slide 4-3

t∆⋅

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 mSmall 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


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 15 RPM.

0.6

Slide 4-7


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


Define > DynamicMesh > ZonesSelect 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


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:

ssm

mvst 018.0

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

Slide 4-10


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

The spots of large cells indicate that our preview time step is too large

Spots with large cells

“Wake” of small cells, as expected

Slide 4-11


We succeed with a preview time step of 0.005 secLet us analyze the mesh motion, to make improvements laterGenerally, we look for:

Cell quality (skewness)Jumps in cell sizeCell count

Slide 4-12


We are wasting too many cells in the “wake” of the valveLet us revisit the dynamic mesh parameters and zones

Large cells adjacent to the coarsely meshed part of the housing

“Wake” of small cells, as expected

Slide 4-13


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 cellsSize jump

Slide 4-14


Effect of ideal height:We had used 0.003 mbefore, and got excessively small cellsHere we tried 0.006 m

Before:

Size jumps

Stretched cells near the moving wall

Slide 4-15


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

Control via ideal heightSlide 4-16

Local Remeshing: Short Example 1/5Compressor 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


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

Slide 4-19


Gear pump

Slide 4-20


Positive displacement pump

Slide 4-21

Agenda








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 markingpreceding 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”) ) thenMark 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

t∆⋅

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

Slide 5-4


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.

Slide 5-5

Cluster of small cells

Squished cells


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:

Slide 5-6

With smoothing!


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.

Slide 5-7

Best mesh

without size

functions

With size functions!

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:

Remeshing & Size Functions: Tips, Limitations

Slide 5-8

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

Remeshing & Size Functions: Tips, Limitations

Slide 5-9

This is a useful debugging tool:

Agenda








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

Slide 6-3

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

(number of moving zones) */#define R2D 180./M_PI

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


The user continues by adjusting the ejector forces in the global coordinate system:

Slide 6-4

/****************************************************************/* Add ejector forces *****************************************************************/static voidadd_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


Notice the Fluent-provided macro (DEFINE_CG_MOTION), which we will discuss in the next section;Also notice the name “six_dof”:

Slide 6-5

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


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

Slide 6-6

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


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:

Slide 6-7

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 velocity

components vx and vy in

m/s

“velocities_3d”

Angular velocity components , and in rad/sec and in body

coordinates

Euler angles in radians

Nonzero angular speed, zω

xω yω zω


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 loadthat library:

Slide 6-8


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:

Slide 6-9

“fluid-bl”

“wall-object”


Slide 6-10

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-11

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.

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


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)

bulletbarrel

Muzzle brake

axis

moving mesh zone (3 faces)static mesh zone

non-conformal interface

static mesh zone

Inner Interface (2 edges)

Slide 6-14


Slide 6-15

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

Final condition at shot exit

Agenda








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

Slide 7-3

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-4

#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;if (time <= 3.0)

cg_vel[1] = - time/3.0;else

cg_vel[1] = - 1.0;cg_omega[0] = 0.0;cg_omega[1] = 0.0;cg_omega[2] = 0.3;

}

dt = dynamic thread pointer

This is the complete UDF:

Note this name


Slide 7-5

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

DEFINE_CG_MOTION; Example 2: Pump

This piston pump is a bent-axis pumpbecause 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 andreciprocates.

Slide 7-6


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)

Slide 7-7

wall and rot_fluid

inlet

stat_int

rot_int (the circular cap on the cylinder)

wall:001

rot-wall-bot

DEFINE_CG_MOTION; Example 2: PumpThe 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


The UDF prescribes the rigid body motion of the piston face as a sinusoidal function of time;

Slide 7-9

#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 !


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

Slide 8-3

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-4

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:

222 Ryx =+

22 xry −=

Best result without sizing functions

(Slide 4-19)

Best result with sizing functions

(Slide 5-14)


Slide 8-5

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

elseposition[1] = - sqrt(R*R - position[0]*position[0]);

}

22 xry −=


Slide 8-6

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

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 us use sizing functions.

Clustered cells at corner

Sparse region


Slide 8-8

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-9

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

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 segment that will be moved – it is called “wall-compliant”, and is shown in red;

Slide 9-4

“wall-compliant”


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


As the wall section moves, the all-quad mesh adjacent to it is smoothed;The spring constant was 0.5

Slide 9-6


So what does the UDF look like?This UDF is a bit trickier;We need to show it over several slides:

Slide 9-7

#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; int n;


Page 2 (of 4) of the UDF:

Slide 9-8

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

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



Slide 9-9

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

{



Slide 9-10

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

}/* End */

New y-position of

node_p


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








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

Here is a listing of the combined UDF (Slide 1 of 3):

Slide 10-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 rotation


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

Slide 10-4

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


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

Slide 10-5

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


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








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

Slide 11-2

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

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

Slide 11-3

In FLUENT 6.1 we had the following restrictions:

– Single zone– Closed loop

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

Slide 11-4

New in FLUENT 6.2:Symmetric boundariesAcross multiple zonesFeature preservation (e.g., corners are preserved)Non-closed loops

New Dynamic Mesh Features in FLUENT 6.2: Remeshing/Smoothing with Dynamic Adaption

Slide 11-5

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

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

Slide 11-7

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

New Dynamic Mesh Features in FLUENT 6.2: 6-DOF Solver

Slide 11-8

6-DOF solver now built into the GUIGUI 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)

New Dynamic Mesh Features in FLUENT 6.2: Dynamic Mesh Events

Slide 11-9

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 zonesChange URF

New Dynamic Mesh Features in FLUENT 6.2: Miscellaneous

Slide 11-10

Improved parallel performance, in particular ICReduced number of cell migrations during mesh updateEncapsulation of non-conformals not required anymore

Zone motion previewMotion history for 6-DOF applications

FLUENT 6.2: Sneak Preview

Slide 11-11


Slide 11-12


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 ?

Slide 0-4

Questions?

Dynamic Mesh Case Studies (FLUENT 6.1)

Christoph Hiemcke

9 June 2004

Thank you for your attention!

Documents

41658132 Dynamic Mesh