Skip to content
Switch branches/tags
This branch is 9 commits ahead of TUDelft-CNS-ATM:master.
Fetch upstream


Failed to load latest commit information.
Latest commit message
Commit time

Open Aircraft Performance Model (OpenAP) and Toolkit

This repository contains all OpenAP databases and a Python toolkit that facilitates data access and performance computation.

OpenAP is a project actively maintained by Junzi Sun from TU Delft.

It is the continuation of his PhD thesis work (between 2015 and 2019). You can read more about OpenAP in this article.

Use the discussion board to give your feedback/suggestions, and use issue board to report bugs.


To install latest version of OpenAP from the GitHub:

pip install --upgrade git+


  • Aircraft
  • Engines
  • Drag polar
  • Kinematic (WRAP model)
  • Navigation


  • 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


Get the aircraft and engine data

from openap import prop

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

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 =, alt=32000)

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)

Compute aircraft fuel flow:

from openap import FuelFlow

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

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

Compute aircraft emissions:

from openap import FuelFlow, Emission

fuelflow = FuelFlow(ac='A320', eng='CFM56-5B4')
emission = Emission(ac='A320', eng='CFM56-5B4')

TAS = 350
ALT = 30000

fuelflow = fuelflow.enroute(mass=60000, tas=TAS, alt=ALT)   # kg/s

CO2 = emission.co2(fuelflow)                    # g/s
H2O = emission.h2o(fuelflow)                    # g/s
NOx = emission.nox(fuelflow, tas=TAS, alt=ALT)  # g/s
CO =, tas=TAS, alt=ALT)    # g/s
HC = emission.hc(fuelflow, tas=TAS, alt=ALT)    # g/s

Access WRAP (kinematic model) parameter:

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()

Generating trajectories

from openap.traj import Generator

trajgen = Generator(ac='a320')

trajgen.enable_noise()   # enable Gaussian noise in trajectory data

data_cl = trajgen.climb(dt=10, random=True)  # using random paramerters
data_cl = trajgen.climb(dt=10, cas_const_cl=280, mach_const_cl=0.78, alt_cr=35000)

data_de = trajgen.descent(dt=10, random=True)
data_de = trajgen.descent(dt=10, cas_const_de=280, mach_const_de=0.78, alt_cr=35000)

data_cr =, random=True)
data_cr =, range_cr=2000, alt_cr=35000, m_cr=0.78)

data_all = trajgen.complete(dt=10, random=True)
data_all = trajgen.complete(dt=10, alt_cr=35000, m_cr=0.78,
                            cas_const_cl=260, cas_const_de=260)

Identify flight phases

import pandas as pd
from openap import FlightPhase

df = pd.read_csv('data/trajectory.csv')

ts = df['ts'].values    # timestamp, int, second
alt = df['alt'].values  # altitude, int, ft
spd = df['spd'].values  # speed, int, kts
roc = df['roc'].values  # vertical rate, int, ft/min

fp = FlightPhase()

fp.set_trajectory(ts, alt, spd, roc)

labels = fp.phaselabel()

Citing OpenAP

  title={OpenAP: An open-source aircraft performance model for air transportation studies and simulations},
  author={Sun, Junzi and Hoekstra, Jacco M and Ellerbroek, Joost},
  publisher={Multidisciplinary Digital Publishing Institute}


Open Aircraft Performance Model and Python Toolkit




No packages published