Requirements

Late generation Matlab, decent processor and a nicely sized internal memory. Just a small amount
of disk space.

Downloading and installation
The tornado source is available at the website as a zip file. Download it and unzip the entire contents
of the file in a directory where you are comfortable with having it. For
example: C:\home\src\matlabs\tornado

! Be sure to keep the directory structure of Tornado. The program will only work if the
subdirectories /aircraft, /aircraft/airfoils, /data and /output are present. You can change this
default setting in the file config.m

Start Matlab and go to the Tornado working directory. Either run the program from here, or change
your Matlab paths so that the Tornado directory and subdirectories are accessible.

Starting the Program

In the Matlab prompt, type and execute:
>Tornado
and the Tornado splash screen and main menu appears.

""""""""""""""""""""""""""""""""""""""""""""""""""""""
" TORNADO V 134 Beta
" Main Menu
"
""""""""""""""""""""""""""""""""""""""""""""""""""""""

Input operations.

[1]. Aircraft geometry setup
[2]. Flight condition setup
[3]. Change rudder setting
[4]. Move reference point

Lattice operations.

[5]. Generate lattice.

Computation operations.

[6]. Processor access

Post processing and interactive operations.

[7]. Post processing, Result/Plot functions
[8]. Keyboard access

Auxiliary operations.

[9]. About / Release Info
[0]. Exit Tornado

Please enter choice from above:

Navigating through the program is done by selecting the number by the desired function in the list.
When entering data, it's either in numerical format, Boolean (0 for no, 1 for yes) or as a string.

Example 1
Computing the characteristics of a simple wing.

Select option number 1 in the main menu, "Geometry Setup", and then select option number
1, "Define new geometry", in the Geometry setup menu. This starts the geometry input loop which
loops over the number of wings and the partitions of each wing.

For this first aircraft geometry we'll just employ one wing (The horizontal stabilizer would usually be
the second, and the vertical tail the third), so answer "1" to the question Number of Wings:

Then, answer "1" to the question Number of partitions for this wing. After this a series of questions
regarding the constitution of this partition follows, answer them as follows:
(What the numbers actually means will be explained later, in case it's not obvious)

Center of gravity x-coordinate: 0
Center of gravity y-coordinate: 0
Center of gravity z-coordinate: 0
Reference point x-coordinate: 0
Reference point y-coordinate: 0
Reference point z-coordinate: 0

-The first six questions will only be asked for the first wing in your design.

Is the wing mirrored in the xz-plane [1 0]: 1
Root chord: 1
Base chord airfoil: 2400
Number of panels chord wise: 5
Partition dihedral [deg]: 5
Number of panels semi-span wise: 5
Span of partition: 2
Taper ratio: 0.7
Tip chord airfoil: 2400
Quarter chord line sweep [deg]: 10
Outboard twist [deg]: -5
Mesh type: 1
Is partition flapped [1 0]: 1
Flap chord in fraction of local chord (0..1): 0.15
Number of chord wise panels on flap: 1
Does control surfaces deflect symmetrically [1 0]: 1

When this loop is done, you'll be back in the main menu. From here select flight condition setup and
define new state. (2, and then 1). In the state setup, enter:

Alpha [deg]: 5
Beta [deg]: 0
Roll angular velocity [deg/s]: 0
Pitch angular velocity [deg/s]: 0
Yaw angular velocity [deg/s]: 0

After which you'll be asked for speed and altitude, in a format of your choice.
Enter which type of speed you whish to enter:

International units:

[1]. True airspeed (TAS) at SSL [m/s]
[2]. True airspeed (TAS) at altitude [m/s, m]
[3]. Equivalent airspeed (EAS) at altitude [m, m/s]
[4]. Calibrated air speed (CAS) at altitude [m, m/s]
[5]. Mach number at altitude [-, m]

Imperial Units:

[6]. True airspeed (TAS) at altitude [kts, ft]
[7]. Equivalent airspeed (EAS) at altitude [kts, ft]
[8]. Calibrated air speed (CAS) at altitude [kts, ft]
[9]. Mach number at altitude [-, ft]

Type of speed selection: 1
True airspeed [m/s]: 100
Apply Prandtl-Glauert Correction [0 1]: 0

When this is done, you're again dumped back into the main menu. Select the option generate lattice,
option 0 -"freestream following wake". The lattice is now initialized and ready for solving. First plot
the geometry to make sure it looks like you intended. Got to post processing, and there select
option 2, geometry plot. This will invoke four plots, one with panels, reference point and mean
aerodynamic chord, one with collocation points and panel normals, one with the vortex layout and
one with a three view drawing of your paneling. Plotting the geometry is not essential for getting a
solution.

When this is done, select the processor access to see the different options regarding the solver.
Here, select simple solution computation. You'll be asked for a Job Identifier (JID). This is just a text
string to help you identify your results among printouts and files.

Enter Job IDentity tag (JID): test

The computer will chew on this for a couple of seconds before invoking the main menu again. When
ready, select Post processing, Result/Plot functions and then select Solution plot, simple state in the
post processing menu. You'll be shown a list of available result files (saved automagically by the
solver function). Type in your JID to plot the results.

Enter JID to plot: test

A couple of result plots should appear. That's it essentially.

Example 2
Working with a saved model.

Start Tornado
Go to the geometry setup menu
Select load geometry
From the list of files, select A320W

>Load file: A320W

From the main menu, generate the lattice with option 0 (Freestream-following wake). This will give
you an error message telling you that no state is loaded. However, you can now plot the geometry
from the post processing menu. Do so and have a look at figure 1. In this figure you can see that the
reference point is positioned at the main wing apex, perhaps not the best position.

To change it, select option 4 in the main menu to get to the move reference point position function:

""""""""""""""""""""""""""""""""""""""""""""""""""""""
"
" Main Menu
" |----->Move reference point
"
""""""""""""""""""""""""""""""""""""""""""""""""""""""

[1]. Move reference point in x
[2]. Move reference point in y
[3]. Move reference point in z

[4]. Move reference point to position on MAC

[0]. Cancel

>Please enter choice from above: 4

Select option number 4, and then:

>Move reference point to percent of MAC [ % ]: 25

When this is done, regenerate the lattice.

!After changes to the geometry or state, always regenerate the lattice!

Plot the geometry from the postprocessor to verify that the reference point has moved.
(You need to close the earlier plot to prevent the new one to be superimposed.)

Enter a state with 5 degs alpha, 0 betha and 0 [P Q R] at sea level and 10 m/s velocity.

Regenerate the lattice and go to the processor access and perform a simple solution.

Give this computation the jid test2. Review the results.

From the main menu, select the option change rudder setting. You'll be asked which rudder to set.
Trailing edge control effectors (CE) are numbered wing wise and span wise (in the same order as
they where defined). In the current design, the first CE is the traditional inboard flap, located on
partition number 2, the second is the outboard flap on the third partition. The third is the aileron
located on partition number 4. Change the aileron setting by selecting rudder 3.

Rudder deflection is defined positive with downwards deflection on the starboard wing. Deflect the
aileron by 10 degrees. Regenerate the lattice and plot the geometry. The flap panels will be
deflected in the geometry plot. Go directly to the solver and compute a simple solution with the jid
test3. Plot the results.

To compare test2 and test3, either do a hardcopy of the results or select the keyboard access in the
main menu. This will allow you to issue standard Matlab commands for analysis. At the keyboard
prompt type:

K>> cd output
K>> ls
K>> load test2-Cx
K>> results

dwcond: 19.0666
F: [200x3 double]
FORCE: [-214.3197 6.8522e-015 2.7851e+003]
M: [200x3 double]
MOMENTS: [7.8870e-013 901.1217 1.0675e-013]
gamma: [200x1 double]
cp: [1x200 double]
CX: -0.0219
CY: 6.9910e-019
CZ: 0.2842
D: 29.2316
C: 6.8522e-015
L: 2.7932e+003
CL: 0.2850
CD: 0.0030
CC: 6.9910e-019
Cl: 2.0283e-018
Cm: 0.0202
Cn: 2.7452e-019
ystation: [40x1 double]
ForcePerMeter: [40x1 double]
CL_local: [40x1 double]

K>> load test3-Cx
K>> results

Some other data appear

K>> cd ..
K>> return

Comparing the two result files, especially the value of the rolling moment coefficient (result.Cl) will
give you an idea on the influence of deflecting the aileron on the rolling moment.

Example 3 (Advanced)

I haven't gotten around writing anymore yet. Do you want to? -Pop me a line. :)
Oh, btw, open the file validate.m This is a stand-alone script which runs Tornado in batch mode.

There are 4 different cases, all which are accessed by setting the switch in the beginning of the file.
Run the scripts, look at the results, and figure out how to do your favorite computation in batch
mode. ;)


Program structure
Memory structure

Tornado uses a struct based memory structure with five major variables. They are

geo
state
ref
lattice
results

geo contains all of the geometry data needed to generate the lattice. It is, in a way, the genes of an
aircraft. Internally geo is structured like this: (the example file P51Da)

geo =
nwing 4 (1x1)
nelem: [3 1 3 3] (1xn)
ref_point: [0 0 0] (1x3)
symetric: [1 1 0 0] (1xn)
startx: [0 7.6000 6.7700 0.2000] (1xn)
starty: [0 0 0 0] (1xn)
startz: [0 1.3000 0.3000 -0.3000] (1xn)
c [4.2000 1.7000 2.4000 5.2000] (1xn)
foil {4x3x2 cell} (mxnx2)
nx [4x3 double] (mxn)
TW [4x3x2 double] (1xnx2)
dihed: [4x3 double] (mxn)
ny [4x3 double] (mxn)
b [4x3 double] (mxn)
T [4x3 double] (mxn)
SW [4x3 double] (mxn)
meshtype [4x3 double] (mxn)
flapped [4x3 double] (mxn)
fc [4x3 double] (mxn)
fnx [4x3 double] (mxn)
fsym: [4x3 double] (mxn)
flap_vector [4x3 double] (mxn)
cg 1 0 0 1 x 3

m is the number of wings and n is the maximum number of partitions on any wing.

nwing number of wings in the design.
nelem number of partitions on each wing.
refpoint postition of the moment reference point.
symetric boolean for if the wing is mirrored in the xz plane
start(xyz) vectors describing where the wing are positioned. The first wing has its apex at the
system origin
c root chord vector, one entry per wing
foil airfoil matrix for each partition, [wing, partition,
(inboard-outboard)]
nx number of chord wise panels matrix for each partition
TW twist matrix for each partition, [wing, partition, (inboard-outboard)]
dihed partition dihedral matrix
ny number of chord wise panels matrix for each partition
b partition span matrix
SW partition sweep matrix
meshtype numerical describing partition type of mesh
flapped boolean for if the partition is flapped
fc percentage of chord which is flapped
nx number of chord wise panels for the flap
fsym boolean for if the flap deflects symmetrically
flap_vector deflection of the flap (or other TE control)
CG coordinates of the design center of gravity, around which all rotations take place.

For example, the sweep matrix could look like this:

geo.SW =
0.2094 0.1000 0.1000
0.1047 0 0
0.3725 1.0996 0.2967
-1.2390 0 -1.7800


Where the row indicate wing number and column the partition number.

The state vector contains data pertaining to the flight condition of the proposed solution. It could
look like this:

state =

AS 10 True airspeed in m/s. The input function recomputes all other speed types to TAS
alpha 0.0873 Angle of attack in radians. Again the input function recomputes
betha 0 Sideslip angle in radians.
P 0 Roll angular velocity rad/s
Q 0 Pitch angular velocity rad/s
R 0 Yaw angular velocity rad/s
rho 1.1116 Air density kg/m^3
ALT 1000 Altitude in meters.


The lattice structure contains the fields:
lattice =
COLLOC [200x3 double] position of the collocation points (x,y,z)
VORTEX [200x8x3double] endpoints of the vortex sling elements
N [200x3 double] panel normal directions
XYZ [200x5x3double] corners of each panel (the first corner twice so that
the matlab
command patch can make a square of it.)

ref =

b_ref 39.6740 Reference span (Span of first wing)
S_ref 160.0219 Reference area (Sum of panel areas on first wing)
C_mgc 4.5052 Mean geometruc chord
C_mac 4.5571 Mean aerodynmic chord
mac_pos [3.4581 0 0.5528] Start position of mac

results contain all computational results for a particular job. For example:
results =
dwcond 19.066 Condition of the solver matrix. 10 is good, 100 is allright,
10^3 could work, 10^4 is kida crappy, 10^5 sucks.
F [200x3 double] Force vector on each panel
FORCE [-214.31972.78] Sum of F
M [200x3 double] Moment about refpoint from each panel
MOMENTS [0 901.1217 0] Sum of M
gamma [200x1 double] Vortex strength on each panel
cp [1x200 double] Panel pressure distribution
CX -0.0219 Longitudinal force coefficient
CY 6.9910e-019 Lateral force coefficient
CZ 0.2842 Cardinal force coefficient
D 29.2316 Drag (only induced drag)
C 6.8522e-015 Side force
L 2.7932e+003 Lift
CL 0.2850 Lift coefficient
CD 0.0030 Drag coefficient
CC 6.9910e-019 Side coefficient
Cl 2.0283e-018 Roll moment coefficient
Cm 0.0202 Pitch moment coefficient
Cn 2.7452e-019 Yaw moment coefficient
ystation [40x1 double] Spanstation for local CL
ForcePerMeter [40x1 double] Local lift spanwise
CL_local [40x1 double] Local CL spanwise



Geometry structure

Wings
The geometry structure follows the memory structure, or vice versa. The aircraft is divided into its
constituent lift generating parts, the wings. Hence fins, stabilizers and other protruding flat plates
are also regarded as wings. A typical division would be main wing, horizontal stabilizer and vertical
fin. The figure below should give you a hint: (click to enlarge)


There are no differences in input or calculation between main wing, stabiliser or fin. To create both
the starboard and the port sides of the main wing, tick wing is mirrored. Do the same for the
stabiliser. As for the fin, dont use the symmetry setting but set the dihedral angle to 90 degrees.
This procedure will give you one wing half with its span directed in the Z-direction.

Partitions
Every wing composed of a number of partitions. The simplest wing contains only one partition while
a more complex one may have five or more. In each partition the wing design features are constant.
Examples are sweep and taper ratio. A partition simply a slab of wing with four corners.

Exceptions are twist and camber which have to be defined with inner and outer values for the first
partition of a wing. Succeeding partitions take the outer feature of the previous element as their
inner feature to assure continuity along the wing's span. Thereby, partitions are numbered
outwards.

Panels
The panels are the small four-corned elements that build up each partition. No special input is
needed to define their shape, as this is auto generated once the number of panels in the chord-wise
and span-wise directions have been entered. In the current version of Tornado the panels are evenly
distributed on the partitions. For reference, panels are numbered from the leading edge backwards
in row by row outwards.