Use OpenAP Python Library

This page provides a list of examples on how to use OpenAP in Python programming language.

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 = thrust.cruise(tas=230, 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

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

CO2 = emission.co2(FF)                    # g/s
H2O = emission.h2o(FF)                    # g/s
NOx = emission.nox(FF, tas=TAS, alt=ALT)  # g/s
CO = emission.co(FF, tas=TAS, alt=ALT)    # g/s
HC = emission.hc(FF, 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 = trajgen.cruise(dt=60, random=True)
data_cr = trajgen.cruise(dt=60, 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()