Flight segments

Flight segments are the Python-implemented, base building blocks for the mission definition.

They can be used as parts in phase definition.

A segment simulation starts at the flight parameters (altitude, speed, mass…) reached at the end of the previous simulated segment. The segment simulation ends when its target is reached (or if it cannot be reached).

Sections:

Segment types

In the following, the description of each segment type links to the documentation of the Python implementation. All parameters of the Python constructor can be set in the mission file (except for propulsion and reference_area that are set within the mission module). Most of these parameters are scalars and can be set as described here. The segment target is a special parameter, detailed in further section Special parameters are detailed in last section.

Available segments are:

speed_change

A speed_change segment simulates an acceleration or deceleration flight part, at constant altitude and thrust rate. It ends when the target speed (mach, true_airspeed or equivalent_airspeed) is reached.

Python documentation: SpeedChangeSegment

Example:

segment: speed_change
polar: data:aerodynamics:aircraft:takeoff   # High-lift devices are ON
engine_setting: takeoff
thrust_rate: 1.0                            # Full throttle
target:
  # altitude: constant                      # Assumed by default
  equivalent_airspeed:                      # Acceleration up to EAS = 250 knots
    value: 250
    unit: kn

altitude_change

An altitude_change segment simulates a climb or descent flight part at constant thrust rate. Typically, it ends when the target altitude is reached.

But also, a target speed can be set, while keeping another speed constant (e.g. climbing up to Mach 0.8 while keeping equivalent_airspeed constant).

Python documentation: AltitudeChangeSegment

Examples:

segment: altitude_change
polar: data:aerodynamics:aircraft:cruise    # High speed aerodynamic polar
engine_setting: idle
thrust_rate: 0.15                           # Idle throttle
target:                                     # Descent down to 10000. feet at constant EAS
  altitude:
    value: 10000.
    unit: ft
  equivalent_airspeed: constant

segment: altitude_change
polar: data:aerodynamics:aircraft:cruise    # High speed aerodynamic polar
engine_setting: climb
thrust_rate: 0.93                           # Climb throttle
target:                                     # Climb up to Mach 0.78 at constant EAS
  equivalent_airspeed: constant
  mach: 0.78

segment: altitude_change
polar: data:aerodynamics:aircraft:cruise    # High speed aerodynamic polar
engine_setting: climb
thrust_rate: 0.93                           # Climb throttle
target:                                     # Climb at constant Mach up to the flight
  mach: constant                            #  level that provides maximum lift/drag
  altitude:                                 #  at current mass.
    value: optimal_flight_level

cruise

A cruise segment simulates a flight part at constant speed and altitude, and regulated thrust rate (drag is compensated).

Optionally, target altitude can be set to optimal_flight_level. In such case, cruise will be preceded by a climb segment that will put the aircraft at the altitude that will minimize the fuel consumption for the whole segment (including the prepending climb). This option is available because the altitude_change segment can reach an altitude that will optimize the lift/drag ratio at current mass, but the obtained altitude will not guaranty an optimal fuel consumption for the whole cruise.

It ends when the target ground distance is covered (including the distance covered during prepending climb, if any).

Python documentation: ClimbAndCruiseSegment

Examples:

segment: cruise
polar: data:aerodynamics:aircraft:cruise    # High speed aerodynamic polar
engine_setting: cruise
target:
  # altitude: constant                      # Not needed, because assumed by default
  ground_distance:                          # Cruise for 2000 nautical miles
    value: 2000
    unit: NM

segment: cruise
polar: data:aerodynamics:aircraft:cruise    # High speed aerodynamic polar
engine_setting: cruise
target:
  altitude: optimal_flight_level            # Commands a prepending climb, id needed
  ground_distance:                          # Cruise for 2000 nautical miles
    value: 2000
    unit: NM

optimal_cruise

An optimal_cruise segment simulates a cruise climb, i.e. a cruise where the aircraft climbs gradually to keep being at altitude of maximum lift/drag ratio.

It assumed the segment actually starts at altitude of maximum lift/drag ratio, which can be achieved with an altitude_change segment with optimal_altitude as target altitude.

The common way to optimize the fuel consumption for commercial aircraft is a step climb cruise. Such segment will be implemented in the future.

Python documentation: OptimalCruiseSegment

segment: optimal_cruise
polar: data:aerodynamics:aircraft:cruise    # High speed aerodynamic polar
engine_setting: cruise
target:
  ground_distance:                          # Cruise for 2000 nautical miles
    value: 2000
    unit: NM

holding

A holding segment simulates a flight part at constant speed and altitude, and regulated thrust rate (drag is compensated). It ends when the target time is covered.

Python documentation: HoldSegment

Example:

segment: holding
polar: data:aerodynamics:aircraft:cruise    # High speed aerodynamic polar
target:
  # altitude: constant                      # Not needed, because assumed by default
  time:
    value: 20                               # 20 minutes holding
    unit: min

taxi

A taxi segment simulates the mission parts between gate and takeoff or landing, at constant thrust rate. It ends when the target time is covered.

Python documentation: TaxiSegment

Example:

segment: taxi
thrust_rate: 0.3
target:
  time:
    value: 300              # taxi for 300 seconds (5 minutes)

Segment target

The target of a flight segment is a set of parameters that drives the end of the segment simulation.

Possible target parameters are the available fields of FlightPoint. The actually useful parameters depend on the segment.

Each parameter can be set the usual way, generally with a numeric value or a variable name, but it can also be a string. The most common string value is constant that tells the parameter value should be kept constant and equal to the start value. In any case, please refer to the documentation of the flight segment.

Special segment parameters

Most of segment parameters must be set with a unique value, which can be done in several ways, as described here.

There are some special parameters that are detailed below.

engine_setting

Expected value for engine_setting are takeoff, climb , cruise or idle

This setting is used by the “rubber engine” propulsion model (see RubberEngine). It roughly links the “turbine inlet temperature” (a.k.a. T4) to the flight conditions.

If another propulsion model is used, this parameter may become irrelevant, and then can be omitted.

polar

The aerodynamic polar defines the relation between lift and drag coefficients (respectively CL and CD). This parameter is composed of two vectors of same size, one for CL, and one for CD.

The polar parameter has 2 sub-keys that are CL and CD.

A basic example would be:

segment: cruise
polar:
  CL: [0.0, 0.5, 1.0]
  CD: [0.01, 0.03, 0.12]

But generally, polar values will be obtained through variable names, because they will be computed during the process, or provided in the input file. This should give:

segment: cruise
polar:
  CL: data:aerodynamics:aircraft:cruise:CL
  CD: data:aerodynamics:aircraft:cruise:CD

Additionally, a convenience feature is proposes, which assumes CL and CD are provided by variables with same names, except one ends with :CL and the other one by :CD. In such case, providing only the common prefix is enough.

Therefore, the next example is equivalent to the previous one:

segment: cruise
polar: data:aerodynamics:aircraft:cruise