Skip to content

openap

Jump to bottom
MJRibeiroTUDelft edited this page Sep 26, 2019 · 31 revisions

The OpenAP performance model allows for using different types of aircraft and obtaining the performance results. For each aircraft type, parameters such as dimensions, limits, nominal cruise condition, and engine options are given.

OpenAP is one of the performance models available in Bluesky.

For more information refer to OpenAP: The open-source aircraft performance model and associated toolkit

Enable OpenAP

In settings.cfg select the following option:

# Select the performance model. options: 'openap', 'bada', 'legacy'
performance_model = 'openap'

Databases

  • Aircraft
  • Engines
  • Drag polar
  • Kinematic (based on the results of a data-driven statistical model (WRAP))
  • Navigation

Use of navigation library:

from openap import nav
print(nav.airport(’EHAM’))
print(nav.closest_airport(52.011, 4.357))
print(nav.fix(’EH155’))
print(nav.closest_fix(52.011, 4.357))

Available Aircraft Types

Types of fix wing aircraft are defined in: Aicraft Types

For rotors aircraft, the types are defined in: Rotor Types

The name of each aircraft object identifies the name which should be used to create each aircraft type.

Libraries

  • prop: aircraft and engine properties
  • thrust: model to compute aircraft thrust
  • drag: model to compute aircraft drag
  • fuel: model to compute fuel consumption
  • kinematic: a utility library to access WRAP data
  • aero: common aeronautical conversions
  • nav: model to access navigation information
  • segment: a utility library to determine climb, cruise, descent, level flight
  • phase: a wrapper around segment, providing identification of all flight phases
  • traj: package contains a set of tools related with trajectory generation

Examples

Get the aircraft and engine data:

from openap import prop

aircraft = prop.aircraft('A320')
engine = prop.engine('CFM56-5B4')

print(aircraft[’wing’][’span’])
print(engine[’max_thrust’])

Compute maximum aircraft engine thrust:

from openap import Thrust

thrust = Thrust(ac='A320', eng='CFM56-5B4')

T = thrust.takeoff(tas=100, alt=0)
T = thrust.climb(tas=200, alt=20000, roc=1000)
T = thrust.cruise(tas=230, alt=32000)

where the inputs of the function are true airspeed (in knots), altitude (in feet), and rate of climb (in feet/minute). The outputs are maximum thrust forces (in Newton).

Compute the aircraft drag:

from openap import Drag

drag = Drag(ac='A320')

D = drag.clean(mass=60000, tas=200, alt=20000, path_angle=5)
D = drag.nonclean(mass=60000, tas=150, alt=100, flap_angle=20,
                  path_angle=10, landing_gear=True)

the inputs of this functions are mass (in kilogram), true airspeed (in knots), and altitude (in feet). The outputs are drag force (in Newton).

Compute the fuel flow:

from openap import FuelFlow

ff = FuelFlow(ac='A320', eng='CFM56-5B4')

FF = ff.at_thrust(thr=50000, alt=30000)
FF = ff.takeoff(tas=100, alt=0, throttle=1)
FF = ff.enroute(mass=60000, tas=200, alt=20000, path_angle=3)
FF = ff.enroute(mass=60000, tas=230, alt=32000, path_angle=0)

the inputs of this functions are thrust (in Newton), mass (in kilogram), true airspeed (in knots), altitude (in feet), flight path angle (in degrees), and throttle setting (between 0 and 1).

Inferring flight phase:

from openap import FlightPhase
FP = FlightPhase()
FP.set_trajectory(ts, alt, spd, roc)
labels = FP.phaselabel() # produce the phase label for each data point
indices = FP.flight_phase_indices() # return the set of indices each phase starts

where we first set the trajectory data. The last two functions produce the flight phase labels, and the indices of the data point when a different flight phase starts.

Accessing the WRAP parameters:

from openap import WRAP

wrap = WRAP(ac='A320')

param = wrap.takeoff_speed()
param = wrap.takeoff_distance()
param = wrap.takeoff_acceleration()
param = wrap.initclimb_vcas()
param = wrap.initclimb_vs()
param = wrap.climb_range()
param = wrap.climb_const_vcas()
param = wrap.climb_const_mach()
param = wrap.climb_cross_alt_concas()
param = wrap.climb_cross_alt_conmach()
param = wrap.climb_vs_pre_concas()
param = wrap.climb_vs_concas()
param = wrap.climb_vs_conmach()
param = wrap.cruise_range()
param = wrap.cruise_alt()
param = wrap.cruise_init_alt()
param = wrap.cruise_mach()
param = wrap.descent_range()
param = wrap.descent_const_mach()
param = wrap.descent_const_vcas()
param = wrap.descent_cross_alt_conmach()
param = wrap.descent_cross_alt_concas()
param = wrap.descent_vs_conmach()
param = wrap.descent_vs_concas()
param = wrap.descent_vs_post_concas()
param = wrap.finalapp_vcas()
param = wrap.finalapp_vs()
param = wrap.landing_speed()
param = wrap.landing_distance()
param = wrap.landing_acceleration()
Clone this wiki locally