| Contents | Previous Chapter | Next Chapter |
Piano does not address issues of engine synthesis or thermodynamic cycle analysis. Instead, engines are modelled in the form of data matrices. These contain all necessary information about thrust and fuel flow (or sfc) under any flight conditions. Existing and projected powerplants are all treated similarly and formatted as 'rubber engines' (meaning they can be scaled to any arbitrary thrust).
Piano includes a substantial database of pre-defined engines. They are based on a variety of actual operational models and design simulations. You can choose any one that is closest to your requirements and scale it to fit your precise needs, either uniformly or by adjusting individual characteristics in different ways. Much of this chapter goes into the fine detail of engine data representations. You do not need to know all of this if you only use the engines provided.
You can also create your own new engine models. To do this you must have detailed information on the engine's performance over a broad range of operating conditions. Data are usually provided by engine manufacturers in the form of large files or so-called 'engine decks'. Piano has a powerful 'deck filter' facility that lets you extract information directly from such files and converts it to the required 'rubber engine' format automatically. Although this is a fast and transparent process, you still need to be aware of how data are formatted.
Engines are kept separately from planes. Any one engine can be linked to several plane files at the same time. In each case, its performance characteristics may be scaled to a different thrust (the reference-thrust-per-engine of that plane, henceforth also called the fn*).
You can load engines with the 'Load Engine...' item (see 'Eng' menu). If you then store your plane, a link is established automatically via the parameter linked-engine-name .
Note that all thrust and fuel flow characteristics refer to 'typical installed' values.
Each engine takes the form of a folder that contains several text files. Individual files describe the various thrust ratings, fuel flow or sfc, and other related characteristics. The following files are required:
max takeoff
max climb
max cruise
max continuous
either fuel flow or sfc loops (but not both)
idle thrust
idle flow
description
Filenames must match the ones shown above exactly. Any other files placed inside an engine folder will be ignored.
All engines must normally reside inside the 'engine data' folder (found in the Piano folder). Although it is also possible to keep engines in other folders that you create, these new folders must also be located directly inside the Piano folder, and not nested at deeper levels. Piano won't be able to find any engines hiding elsewhere.
Thrust rating files describe the maximum available thrust under standard rating definitions (max takeoff, max climb, max cruise, and max continuous; sometimes abbreviated to mto, mcl, mcr, and mco respectively).
Each rating file contains the variation of 'fractional thrust' with Mach number and altitude. 'Fractional thrust' is the thrust divided by reference-thrust-per-engine . This ratio will henceforth also be called fn/fn*.
Altitudes must always be given in feet. At each altitude, you can input any number of points (as pairs of Mach and fn/fn*). The following shows a typical 'max takeoff' file, with data at 0, 5000, and 10000 feet and at Mach 0, 0.2, and 0.4 :
Altitude 0 0 1.000 0.2 0.812 0.4 0.655 Altitude 5000 0.0 0.897 0.2 0.725 0.4 0.598 Altitude 10000 0 0.802 0.2 0.654 0.4 0.544The word 'Altitude' is merely a convenient delimiter. It can be replaced by another word, such as 'alt'. Data do not need to be uniformly spaced or 'square'.
The remaining rating files ('max climb', 'max cruise', 'max continuous') have a similar structure, although clearly they should cover more values of Mach and altitude than shown in the above example. The fn/fn* must be a typical 'installed' value.
All 'fractional thrust' found in files will be scaled to the reference-thrust-per-engine (also called fn*). This can be any arbitrary datum chosen by you or the manufacturer. However, it often coincides with, or is near to, the sea-level static thrust (SLST). The reference-thrust-per-engine will differ from the SLST whenever the 'max takeoff' file has a datapoint at (altitude=0, mach=0) whose value of (fn/fn*) is other than 1.0.
In general, the available thrust at any rating is the product of the (fn/fn*) data held on file , the reference-thrust-per-engine (fn*), and a user-factor on the rating. The relevant factors are user-factor-on-takeoff-rating , user-factor-on-climb-rating , user-factor-on-cruise-rating and user-factor-on-continuous-rating . They all default to 1. The user-factor-on-takeoff-rating in particular can simulate either a 'throttle push' or a 'de-rate' of the engine. It affects takeoff performance without changing other engine characteristics. Such situations arise often with digital engine control systems (FADEC).
You can check the available thrust under any conditions via the 'Point Performance...' item (see 'Eng' menu). The 'Basics' report under the 'Report' menu shows both the reference and available SLST thrusts.
Note: Manufacturers often use their own arbitrary definitions of reference thrust. For example, the 'Boeing Equivalent Thrust' (BET) is defined as (sea-level ISA thrust at Mach 0.25) * 1.255. Such definitions are little more than rough 'average' thrusts for the takeoff run. If you need it, the BET is nominally shown in the 'Max Takeoff' picture under the 'Dimensional...' item ('Eng' menu). It should not be confused with the available SLST.
Thrust interpolation options are shown in the 'Thrust Interpol.' item (see 'Eng' menu). By default, interpolation is linear (:linear-interp), and the engine produces zero thrust outside the available data range. If :linear-extrap is chosen, extrapolation is allowed in the Mach direction only. Smooth interpolation or extrapolation (:smooth-interp or :smooth-extrap) uses a spline fit.
You should be aware that smoothing can produce unwanted oscillations if the data are inherently rough. Also, smoothing without extrapolation may restrict the range of usable data, unless the matrices are 'square' (covering the same Machs at all altitudes).
If you make a selection via the 'Thrust Interpol.' item, the effect is temporary and is not saved on file. To permanently fix the interpolation for a given engine, you must add a suitable line in your engine's 'description' file. (This file is discussed in a later section). For example:
thrust-interpolation :smooth-extrapor one of the alternatives (:linear-extrap, :smooth-interp), as required. Note that the name must start with a colon.
Altitude coverage within the data files should cater for the margins of the flight regime. If an aircraft is expected to cruise at its max-operating-altitude , it is best to have engine data that extend a few hundred feet above it. Altitude extrapolation is not attempted.
Fuel flow (or sfc) depends on three parameters: Thrust setting, Mach number, and Altitude. This means that you have basically two choices:
-1. The 'complete' or 'brute force' approach, whereby you provide full data coverage. This involves inputting a separate data matrix at each altitude to cover the variation with thrust and Mach at that altitude, and doing so over a broad enough range of altitudes.
-2. The compact or 'generic' approach. This involves reducing the variation with altitude to a built-in standard format. All fuel flows can then be calculated from a single data matrix. Although it means trading off some accuracy for compactness, the loss of accuracy is small. You can, if you wish, also provide corrections through a small amount of additional data. This effectively eliminates any discrepancies at the most common operating conditions.
The 'complete' approach carries a substantial penalty in terms of the resulting volume of data, and little benefit in terms of accuracy. Nonetheless, you may prefer it if you possess a complete 'engine deck', as it is straightforward to implement. You just run your data through the 'Eng Deck Filter', and your engine is ready.
The 'compact' approach requires some data manipulation (the tools for which are provided) in order to create the generic form of the fuel flow curve. However the resulting engine representation is very compact.
Both alternatives are discussed in detail in the following sections. There is no difference when it comes to usage; either engine representation is the same to all planes.
You can supply your data either in terms of fuel flow or sfc. However, the best choice is 'fuel flow', since by definition the concept of sfc is problematic near idle thrust settings.
Data should be typical installed values. The parameter user-factor-on-sfc can be used to factor either fuel-flow or sfc characteristics uniformly.
This section describes the generic (compact) way of representing fuel flow or sfc.
A 'fuel flow' file contains data on the variation of (transformed fuel flow) with Mach number and (transformed thrust). The definitions of these are:
(transformed fuel flow) = fuel flow / fn* / delta / (theta ^ n) {lb/hr/lbf}
(transformed thrust) = thrust / fn* / delta
'delta' is the atmospheric pressure ratio (p/p0)
'theta' is the atmospheric temperature ratio (t/t0)
'n' is the theta-exponent, a number of the order of 0.62
'fn*' is the reference thrust.
The inclusion of 'delta' and 'theta' in these equations is what gives the required variation in terms of altitude.
To produce such data, choose a typical altitude near cruise conditions (say 35000 ft) and obtain the fuelflow (lb/hr) as a function of thrust (lbf) for several Mach numbers. Try to cover as wide a range of thrust as possible. Calculate the 'delta' and 'theta' at this altitude, pick a value for theta-exponent (0.62 is recommended), then apply the transformation shown above. The resulting data apply to any altitude. You just input a corresponding delta and theta and invert the operation to find the thrust.
You do not have to do all this by hand! Piano has a facility for transforming the data automatically (see 'Transform Data' under the 'Eng' menu). This is explained later.
Here is an example showing the precise format of a 'fuel flow' file:
theta-exponent 0.62
Mach 0.0
0.11821 0.07335
0.47322 0.17659
0.70983 0.26070
0.94644 0.36086
1.25145 0.52627
Mach 0.2
0.10022 0.08515
0.40068 0.19615
0.60072 0.28044
0.80115 0.37754
1.06583 0.53657
Mach 0.4
0.08974 0.09723
...... etc ......
The file starts with the word theta-exponent and its value. The rest are pairs of data at several Mach numbers, representing (transformed thrust) and (transformed fuel flow) respectively.
Instead of 'fuel flow', you can provide a file called 'sfc loops'. The only difference is that (transformed fuel flow) is replaced by (transformed sfc):
(transformed sfc) = sfc / (theta ^ n) {lb/hr/lbf}
This is just the same as dividing (transformed fuel flow) by (transformed thrust). Piano relies on the filename to decide which of the two representations has been used.
You can choose a fuel interpolation option from the 'Fuel Interpol.' item (see 'Eng' menu). Similar comments apply to those made earlier about thrust interpolation. The default method is :linear-extrap (fuel flow curves are usually well behaved). To make sure that your engine always uses some other interpolation, you must include a line in the 'description' file of you engine, for example:
fuel-interpolation :smooth-extrapor one of the alternatives (:linear-interp, :smooth-interp). Note that the name must start with a colon (:).
The transformation used in compact 'fuel flow' or 'sfc loops' files gives a good approximation to the variation of fuel flow (or sfc) with altitude. The fit will be exact at the 'typical' altitude where the transformed data were generated. You can, if you want, supply a correction line to improve the fit at other altitudes. The correction must be typed into the 'description' file of your engine. For example:
altitude-sfc-correction ( 0 0.992 10000 1.0065 20000 0.997 35000 1.0 )The numbers must be surrounded by parentheses. They represent alternately an altitude (always in feet) and a corresponding factor for the fuel flow (or sfc). To derive the necessary factors, use the 'Point Performance...' item to see the calculated values and compare them to actual values at altitudes other than your 'typical' altitude. You can assume max. cruise rating and a nominal Mach at each altitude. Strictly speaking, slight discrepancies would remain at other conditions, but these are very minor.
Note: A similar style of correction exists to let you adjust sfc with delta-ISA. This is rarely used. The format is:
delta-isa-sfc-correction (-10 0.996 0 1 +10 1.004)
This section describes the 'complete' way of representing fuel flow or sfc. For this you need to have a full set of fuel flow (or sfc) data at each altitude, over several altitudes.
Instead of a file called 'fuel flow' (as used in the 'compact' representation), you now provide a folder of the same name. Inside this 'fuel flow' folder, there can be any number of files whose names correspond to altitudes (in feet). So you might have files called 0, 5000, 35000, 41000, etc.
Each file contains data at the named altitude, showing the variation of the parameter (fuel flow / fn*) with the fractional thrust (fn/fn*), at various Mach numbers. For example:
Mach 0 0.01177 0.00870 0.01882 0.01076 ...... etc ..... 0.32944 0.09472 Mach 0.4 0.01177 0.01088 0.01882 0.01424 ...... etc .....The first column is (fn/fn*). The second is (fuel flow / fn*), in units of lb/hr/lbf. Note that this parameter is merely a normalised version of the fuel flow because fn* is a constant value, although the units come out in lb/hr/lbf (like an sfc).
You can, if you prefer, have an 'sfc loops' folder instead of a 'fuel flow' folder. The format of this is exactly the same, except that the parameter (fuel flow / fn*) is now replaced by the actual sfc, in lb/hr/lbf.
Interpolation for the 'complete' representation is always linear, because it is effectively impossible to achieve or verify smoothness in all directions for realistic data inputs.
Idle characteristics are used during descent calculations and for taxi allowances. No distinction is made between flight idle and ground idle. However, you can simply ensure that your input at (altitude=0, mach=0) matches the ground idle.
The 'idle thrust' file shows the variation of idle 'fractional thrust' (idle thrust / fn*) as a function of Mach number, at different altitudes (in feet). Note that idle thrust can also take negative values. For example:
Altitude 0 0.00 0.0300 0.50 -0.0148 0.85 -0.0561 Altitude 10000 0.00 0.0300 0.50 -0.0074 0.85 -0.0360 ..... etc .....The format of the 'idle flow' file is similar, except that it contains data for the normalised idle flow (idle fuel flow / fn*), in lb/hr/lbf, instead of thrust.
The 'description' file is a convenient place to put any comments. A semicolon (;) is the comment-out character. Anything following it is ignored, until the next line. Note that the 'Load Engine...' feature displays a useful 'preview' of the first few lines of the description file.
Description files also accept a variety of key words, followed by their values. Key words specify additional engine characteristics. These four have already been described:
fuel-interpolation
thrust-interpolation
altitude-sfc-correction
delta-isa-sfc-correction
Another key word is engine-type . Piano treats all types of powerplant in the same generic manner. However, a few calculations (windmilling drag, engine maintenance costs, and nacelle drag estimates) may depend on the type. This can be one of the following:
engine-type :turbofan (the default, if no value is specified)
engine-type :turboprop
You can provide engine emissions data via the following key words:
fuel-kg/s-EINOx-g/kg
fuel-kg/s-EIHC-g/kg
fuel-kg/s-EICO-g/kg
These are described in detail in Chapter#12section02 and Chapter#12section04 .
More types of data accepted by the 'description' file are described in the following sections.
All engine data refer to standard (ISA) conditions. During takeoff and climb calculations, variations of thrust with temperature (delta-ISA) may also be required. You can specify these in the 'description' file, using a separate key word for each rating, as in this example:
mto-flat-rating (0 1 +15 1 +25 .93)
mcr-flat-rating (0 1 +15 1 +25 .93)
mcl-flat-rating (0 1 +15 1 +25 .93)
mco-flat-rating (0 1 +15 1 +25 .93)
Each key word is followed by a list of numbers enclosed in parentheses (). The numbers are alternately a deviation from ISA (delta deg.C.) and the factor to be applied to the corresponding ISA thrust.
'Flat-rated' engines maintain an approximately constant performance up to a certain temperature. In the above examples, thrust is constant to ISA+15 deg.C., then shows a 7% loss over the next 10 degrees. Interpolation is linear. If flat rating characteristics are not specified, the data shown in this example are used by default.
The flat-rating may sometimes also vary with altitude. An alternative format can then be used, as in this example:
mto-flat-rating
( Altitude 0
+0 1.0
+15 1.0
+25 .93
Altitude 3000
+0 1.0
+12 1.0
+25 .90
Altitude 35000
+0 1.0
+06 1.0
+25 .75 )
The altitude must always be in feet.
Note: The term 'flat-rating' is occasionally also used to describe a flat variation of thrust with speed. This is covered in the 'max takeoff' file.
Some of the parameters commonly found inside 'plane' files can also be specified in the 'description' file of an engine. For example:
bypass-ratio
engine-pressure-ratio
number-of-compressor-stages
number-of-shafts
blades-per-propeller
propeller-diameter {this must be given in metres}
Since Piano does not analyse the thermodynamic cycle, these are only required for their secondary effects on maintenance cost calculations and windmill drag. They do not affect engine performance. Parameter names must be typed in (or copied/pasted in) and followed by a value in the units specified in this section.
When you load a plane that is linked to a particular engine, any values given in the plane file take precedence over those in the engine's description file. If at some point you load an engine manually (via 'Load Engine...'), all values in its 'description' file are also loaded and become the current values. (A warning listing any changes is shown in Piano's output window). Whenever you store the plane (via 'Store Plane...'), any current values will of course be assigned to the plane file.
The engines in Piano's database are 'rubberised' engines. They do not explicitly refer to their original thrust or weight. However, you can specify the true identity of an engine more fully by typing the following parameters in the 'description' file:
reference-thrust-per-engine {must be given in newtons}
mass-per-powerplant {must be given in kg}
or powerplant-thrust/weight
Such engines are called 'fully specified' engines. According to the logic described above, such an engine can still be scaled to any thrust and weight when linked to a particular plane, because the plane's values take precedence. However, every time you use 'Load Engine...', you will get the 'true' thrust and weight from the 'description' file.
It is also possible to specify a particular nacelle shape and dimensions (see Chapter#03section07 and Chapter#03section08 ) through the parameters:
nac-name {in double quotes, e.g. "default"}
nac<fin>-name
nac-width {must be given in metres}
nac-depth/width
nac-length/width
nac<fin>-width-proportion
nac<fin>-depth-proportion
nac<fin>-length-proportion
You can also input the various user-factors related to engines. A useful trick is to simply set these to 1 in the description file. This will ensure that any different current values will be cleared whenever that engine is loaded manually:
user-factor-on-sfc
user-factor-on-climb-rating
user-factor-on-cruise-rating
user-factor-on-continuous-rating
user-factor-on-takeoff-rating
Whether you create new engines as 'fully specified' engines or as non-attributable 'rubber' engines is entirely up to you.
Engine 'deck' files are usually presented in some kind of multi-column format, possibly interspersed with comments or peripheral data. Individual columns correspond to various flight conditions, rating codes, exhaust gas temperatures, etc. Some of this may be relevant information and some may not. Piano's filter can handle decks directly if they fit this general description (see 'Eng Deck Filter', 'Eng' menu). At most, some tidying-up with a spreadsheet, or the insertion of an 'identifier' line may be the only thing needed to rearrange them into a broadly recognisable layout.
Decks should be in the form of a simple text file and can be imported from any kind of source. It is convenient to keep such files in the 'raw eng' folder. This folder does not have any special status, it is just a useful storage area for 'raw' data.
Engine Deck files can start with any descriptive text. Piano looks through this until it finds a recognisable identifier line, to be followed by an indefinite number of rows of corresponding numeric data. The identifier line will typically contain some or all of the following symbols (which are not case-sensitive), in any order:
ALT XM RC FN WF SFC DTAMBwhere:
alt = Altitude (feet) xm = Mach number rc = Rating Code (a number) fn = Thrust, net (lbf) wf = Fuel Flow (lb/hr) sfc = sfc (lb/hr/lbf) dtamb = Delta ISA (deg C)The following synonyms are allowed: mn = xm, ff = wf, isa = dtamb. You can use the 'factor' boxes to cater for units other than those specified above.
The standard Rating Code numbers are 50 = max takeoff, 45 = max continuous, 40 = max climb, 35 = max cruise, and 20 = low idle (for descent). A dummy rating code (by default = 0) is used to identify fuel flow datapoints.
A sample deck file is included in the 'raw eng' folder. Data can be freely formatted and separated by either tabs or spaces.
Extra symbols are allowed in the identifier line provided you declare them through the 'Ignore' button. This lets you skip over any unnecessary data columns such as EGT, N1, N2, TAS, CAS, etc. Nothing else must appear in the identifier line.
The minimum requirement is to provide alt, xm, rc, fn, plus one of either wf or sfc. If both wf and sfc are provided, information is preferentially extracted from the wf. It is best to avoid giving sfc alone, because sfc is ill-defined during idle. Note that Piano engines are modelled at ISA conditions: The identifier dtamb, if present, is only intended to filter out non-ISA data.
You can extract all data in a single-click operation ('Extract All to Folder'). This creates a new engine that is immediately usable by Piano - assuming all data were provided. Any text that appears prior to the identifier line will be placed in the 'description' file for the new engine. This text will be 'commented out' automatically (using a semicolon ;) except for any lines that start with allowable Piano parameters such as bypass-ratio etc.
Data can be extracted 'raw' (unscaled), or scaled to a user-specified reference thrust, or automatically referenced to the SL/ISA/static/max.takeoff point (assuming one appears in the Deck). Recall that Piano expects all engine data to be scaled to some reference thrust.
The rows of data that follow the identifier line can appear in any random order. Data is read from each row in the order of the identifier line. Rows that do not match the identifier (in terms of the number of items) are simply ignored, as are blank rows and those that contain unidentifiable non-numerical data.
If you don't have a full engine deck, you may want to model a new engine as best you can from partial information, inputting data by hand or modifying existing files. This section describes some tools that can be helpful during such exercises.
Text files for engine data can be created via the standard 'File' menu, or by any other text editor, or imported as standard (ASCII) text from other sources. Sometimes it is convenient to start with a duplicate of a complete existing engine, rename and load it, then edit individual files as necessary through 'Edit Engine...' ('Eng' menu). Note that if a particular engine is used by the current plane, and a file belonging to that engine is edited, the changes will not be available until the engine is loaded again.
For convenience, unprocessed data can be placed inside the 'raw eng' folder within the Piano folder. There are various features under the 'Transform Data' sub-menu that convert 'raw' data to the normalised format required by Piano. All these tools operate on the data shown in the current front-most text window:
- Raw Thrust or Idle Data should be the actual thrust in (in lbf.) as a function of Mach number, in blocks of different altitudes (in feet).
- Raw Fuelflow Data should be the actual fuel flow (in lb/hr) as a function of thrust (in lbf.) in blocks of different Mach numbers. Each file must correspond to one altitude.
- Raw SFC Data should be the actual sfc (in lb/hr/lbf) as a function of thrust (in lbf.), in blocks of different Mach numbers.
Several example files are included in 'raw eng'. To process a raw file, first open it via the 'Edit Raw Eng File...' item. Then, making sure that it is the front-most window, select the appropriate option from the 'Transform Data' item. You will be asked to input values for the original reference thrust (fn*), the altitude at which the fuel flows or sfc were created, and maybe a value for theta-exponent (0.62 is recommended). The transformed, normalised data are then shown in a new window. This can be saved as a new file (use 'Save As...' with the appropriate folder and filename), or copied and pasted to an existing file.
It is also possible to apply arbitrary transformation functions, just like a spreadsheet, via the 'Define Transformation' item. You can type-in a formula in terms of the first or second column (labelled c1 or c2), or the independent parameter (labelled p). The transformation is then applied to the data contained in the front-most window, and the results shown in another new window. For example, you can factor a complete dataset up or down, shift all sfc or thrust data to the left or right by some amount, account for different units, etc.
The 'Plot Data' item generates an instant plot of all the data shown in the front-most window (the window does not have to be saved). It works with either raw or transformed files, or any kind of similar two-dimensional data. It is always a good idea to check your manual data inputs with 'Plot Data', to spot gross errors. After loading a newly-created engine, you should also check a sample of representative conditions using the 'Point Performance...' item.
| Contents | Previous Chapter | Next Chapter |