The finite_wing user macro computes a finite length simulation of the air flow over a wing. The macro also creates a probe than can be used to help visualize the air flow.
| Name | Type | Description | UI Control |
| Angle_of_Attack | double | Angle of attack of finite wing. | Slider |
| Wing_span | double | Wing span of finite wing. | Slider |
| Grid_size | int | Number of elements in calculation grid. | Slider |
| probe_z | int | Height of visualization probe. | Slider |
| scan_probe | int | Scans probe through all heights. | Toggle |
| Name | Type | Description | |
| probe_x probe_y probe_z |
float | Transformation of probe geometry. | |
| probe_scale | float | Scaling of probe geometry. | |
| wing_x wing_y wing_z |
Transformation of wing geometry. | ||
| wing_scale | Scaling of wing geometry. | ||
| Name | Type | Description | |
| out_fld | Uniform Vector Field | Simulated air-flow velocity data. | |
| out_obj | DataObject | Directly renderable data object. | |
| out_probe | Line3D | Probe geometry field. | |
| out_probe_obj | DataObject | Directly renderable probe object. | |
| out_wing_obj | DataObject | Directly renderable wing object. | |
The finite_wing user macro calculates the velocity field induced by steady, inviscid, incompressible flow around a finite length wing. It allows the user to specify the parameters of the simulation and outputs the resulting simulation data as a uniform field containing the velocity at each point. The velocity is represented as a 3 component vector of double precision type. The macro also outputs two pieces of line geometry. It outputs a line that represents the position of the wing and it outputs a line probe. This probe can be used as the starting point for various visualizations, such as streamlines and advectors. The user interface allows the height of the probe to be easily altered. It also allows the user to scan the probe through a range of heights.
The simulation contained in the finite_wing macro was originally created as part of a research project conducted by a MSc student at the University of Manchester. The aim of the project was to create a mathematical model of the flow around a finite length wing that could be used as an aid in the teaching of aerodynamics students. Because of this a number of compromises had to be made to ensure that the simulation could be run in a reasonable time. The most significant of these was in the method used to simulate the air-flow.
The simulation of air-flow around an infinite length wing is a relatively simple problem. The aerofoil can be replaced with a bound straight vortex filament of strength equal to the circulation around the aerofoil. This provides a basic model of the air-flow. As the aerofoil has an infinite span the flow in any plane perpendicular to the aerofoil is identical and hence the flow can be considered to be two-dimensional.
Obviously this simplification cannot be made in the case of a finite length wing. Another problem is caused by Helmholtz's Vortex Theorems. This states that a vortex filament cannot end within the boundaries of the fluid. If we modelled our finite wing by a single vortex filament was condition would be broken. Frederick W. Lanchester suggested a solution to this problem in 1907. He modelled a finite wing as a horseshoe vortex where the two trailing legs of the vortex extend out of the fluid to infinity. Ludwig Prandtl later extended this idea by using a lifting line consisting of an infinite number of horseshoe vortices. This model later became known as Prandtl's Lifting-Line Theorem.
Prandtl's theorem provides a more accurate simulation of the downwash induced by a finite wing. However it is also significantly more expensive to calculate. Because of this the finite wing model presented here uses a single horseshoe vortex.
As a result of this simplification the finite wing simulation could be run interactively. To fully exploit this interactivity the simulation code was converted into a AVS/Express module. This allows the student using the simulation to very quickly alter a parameter and visualize its effect. This integration of simulation code into AVS/Express was probably the most novel and successful aspect of the project. It is believed that this technique could be used in many other application areas with similarly successful results.
Angle_of_Attack
Double precision parameter that specifies the angle of attack for the finite wing simulation.
Wing_span
Double precision parameter that specifies the wing span of the finite wing.
Grid_size
Integer parameter that specifies the size of the calculation grid. The calculation grid is always cubic so this parameter completely specifies the size of the grid. The size of the grid must be an odd number. If a even number is supplied then it is automatically rounded up to the next odd number. The size of the grid must be in the range 11 to 51. However a grid size of 51 requires a huge amount of memory. On a typical workstation computer the maximum grid size you should use should be around 35 elements.
probe_z
Float parameter that specifies the height of the output line probe. This user interface control is provided so that the user can more easily move the probe. The probe can still be transformed in all the standard ways. However it should be noted that whenever the simulation is run the position of the probe is reset.
scan_probe
Integer parameter that is used to trigger the scanning of the line probe. Whenever this parameter is activated the line probe is smoothly moved vertically upwards. This allows the user to get a good idea of how the air-flow changes with height. Internally this parameter controls the operation of a loop module. This loop module can be directly edited if you wish to have greater control of how the scanning is done.
probe_x probe_y probe_z
Integer parameters that specify the translation that should be applied to the line probe. Whenever the simulation is run these parameters are reset so that the probe is level with the aerofoil. The position of the line probe can be altered by either using the user interface control or by transforming the probe using the standard AVS/Express tools.
probe_scale
Integer parameter that specifies the scaling that should be applied to the line probe. Whenever the simulation is run this parameter is reset so that the probe covers the full width of the calculation grid.
wing_x wing_y wing_z
Integer parameters that specify the translation that should be applied to the wing geometry. Whenever the simulation is run these parameters are reset so that the wing geometry is in the appropriate position.
probe_scale
Integer parameter that specifies the scaling that should be applied to the wing geometry. Whenever the simulation is run this parameter is reset so that the wing geometry has the appropriate wing span.
out_fld
Uniform vector field output that contains the calculated simulation of the velocity field over the finite length wing. The uniform grid is of length Grid_size on each axis. The velocity data is stored as a 3 component vector of double precision type. The data contained in the field can be visualised by any of the vector visualization modules(e.g. glyph, streamline, advector) Alternatively the magnitude module can be used to calculate the scalar velocity at each point.
out_obj
Directly renderable version of the field output. Normally this output will not be used as attempting to visualize the raw data will not be useful.
out_probe
Mesh output that contains the line probe. This output can be used as the probe input for various visualization modules. For instance, if this output is feed into the streamline module the calculated streamlines will start from the current probe position. The probe has 50 sampling points along its length. It should be noted that normally the calculation grid will have significantly fewer grid points. Therefore AVS/Express will interpolate the data to generate the extra data points.
out_probe_obj
Directly renderable version of the probe output. If this output is feed into a viewer the user can get immediate visual feedback as to the current position of the probe.
out_wing_obj
Directly renderable wing geometry output. If this output is feed into a viewer the user can visually see the current position and size of the simulated finite wing.
The finite_wing user macro uses the FiniteWingUI user interface macro and the FiniteWingFunc functional macro. The FiniteWingFunc macro uses the low-level FiniteWingCore module. All of these macros and modules use the FiniteWingInputParams and FiniteWingOutputParams parameter blocks to communicate parameters.
The HorizontalLine3D utility macro is used to generate the probe line and wing geometries.
The FiniteWingEg example application is provided. This application uses the finite_wing macro to generate the simulation data. This data is then visualized by streamline, advector and bounds modules.
iac_proj/f-wing/fwg-mods.v contains the V definitions of the FiniteWingCore module, the HorizontalLine3D utility macro and the FiniteWingInputParams and FiniteWingOutputParams parameter blocks.
iac_proj/f-wing/fwg-macs.v contains the V definitions of the FiniteWingUI user interface macro, the FiniteWingFunc functional macro and the finite_wing user macro.
iac_proj/f-wing/fwg-apps.v contains the V definition of the FiniteWingEg example application.
The low-level FiniteWingMods library containing the low-level FiniteWingCore module does not specify a process. By default the express process will be used.
Iestyn Jowers, University of Manchester
Andrew Dodd, International AVS Centre
International AVS Centre Manchester Visualization Centre Manchester Computing University of Manchester Oxford Road Manchester United Kingdom M13 9PL