Dynamic Mesh
Short Description
Download Dynamic Mesh...
Description
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
z
z
z
Automotive piston moving inside a cylinder A flap moving on an airplane wing A valve opening and closing 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 “incylinder” 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 domains (e.g. cylindrical geometry).
Constant Height Edges “i” and “i+1” have same shape
Initially, piston at bottom-most position
Piston at top-most position
Edge “i” Slide 2-6
Constant Ratio Edge “i+1” is an average of edge “i” and the piston shape
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 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.
Cool exterior Hot air Oven interior
Static zone Dynamic zone
box
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 nonconformal, 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 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)
)
1.0
0.0
FLUENT profile:
15.0 Slide 2-13
Time (sec)
Layering Example 2: Conveyor Belt Cell layers in the dynamic zone slide past the static zone at a nonconformal, 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 (three line segments)
fluid-static
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 (“wallbox”) 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 edge “inlet-left-bottom”
Cell destruction at stationary 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.
Slide 2-22
Premixed combustion (temperature contours)
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 reestablished. 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 for projection)
“walls-vertical” Slide 3-7
Spring Smoothing Ex. 1: Irregular piston
The nodes belonging to “wallsvertical” 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 (omega_z
0
0.6
1.0
2.2
2.6
3.2)
0.0 1.571 1.571 -1.571 -1.571 0.0)
)
The valve first rotates CCW through 90 degrees, then CW; The maximum rotational speed is 15 RPM.
Omega_z (rad/s) 1.571 0.0
3.2 0.6
Slide 4-7
Time (sec)
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 =
v
=
0.16m / s
= 0.018s
Slide 4-10
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)
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
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
“Wake” of small cells, as expected Slide 4-13
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:
Size jump Slide 4-14
More efficient use of cells
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 summary:
Control via min. cell volume
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 springloaded 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: 2.
3.
4. 5. 6.
Mark all cells whose skewness is above “Maximum Cell Skewness” 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 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]); Move the object/boundary; Perform smoothing iterations (if smoothing is turned on); 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 Mass of the rescue pod (15,000 kg)
Second moments of inertia of the rescue pod
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
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);
In this case, the ejector forces and moments are zero
if (dfront
View more...
Comments
