Emissions module

The compute_emissions function in the AEIC.emissions module uses a PerformanceModel, a Fuel definition and a flown Trajectory to compute emissions for the entire mission.

Emissions are computed for the flown trajectory, LTO operations, APU use, GSE use, as well as life-cycle CO₂ emissions, for all requested species. Emissions methods for different species are controlled by options in the [emissions] section of the configuration data (represented by the EmissionsConfig class).

The output from the emissions calculations include per-species emission indices (grams per kilogram of fuel) and emission values (grams), all wrapped in a single EmissionsOutput value for downstream analysis.

Usage example

import tomllib

import AEIC.trajectories.builders as tb
from AEIC.config import Config, config
from AEIC.performance.models import PerformanceModel
from AEIC.trajectories.trajectory import Trajectory
from AEIC.missions import Mission
from AEIC.emissions import compute_emissions
from AEIC.types import Fuel, Species, ThrustMode

Config.load();

perf = PerformanceModel.load(config.file_location(
    'performance/sample_performance_model.toml'
))

missions_file = config.file_location('missions/sample_missions_10.toml')
with open(missions_file, 'rb') as f:
    mission_dict = tomllib.load(f)
mission = Mission.from_toml(mission_dict)[0]

with open(config.emissions.fuel_file, 'rb') as fp:
    fuel = Fuel.model_validate(tomllib.load(fp))

builder = tb.LegacyBuilder(options=tb.Options(iterate_mass=False))
traj = builder.fly(perf, mission)

output = compute_emissions(perf, fuel, traj)

print("Total CO2 (g)", output.total[Species.CO2])
print("Taxi NOx (g)", output.lto[Species.NOx][ThrustMode.IDLE])
print("Per-segment PM number", output.trajectory[Species.PMnvol])

Computation workflow

The compute_emissions function calculates emissions for a given trajectory, based on a specific performance model and fuel. It performs the following steps:

1. Calculate fuel burn per segment along the trajectory from the fuel mass values provided in the trajectory.

2. Calls the AEIC.emissions.trajectory.get_trajectory_emissions function to calculate per-segment emission indices and emission values along the trajectory. (If the emissiosn configuration flag climb_descent_mode is set to lto, trajectory emissions are only returned for the cruise phase of the flight.)

   • For some species (CO₂, H₂O, SO₂, SO₄), constant fuel-dependent emission index values are used.

   • For other species (NOₓ, volatile and non-volatile particular matter), emissions are calculated using the user-specified calculation method.

   • NOₓ emissions are divided into NO₂, NO and HONO emissions using fixed speciation ratios.

3. Calls the AEIC.emissions.lto.get_LTO_emissions function to calculate ICAO-style landing and take off emissions using the per-mode inputs embedded in the performance file. (If the emissiosn configuration flag climb_descent_mode is set to trajectory, LTO emissions are not returned for the climb and approach phases of the flight, since these are included in the trajectory emissions.)

4. If APU emissions are requested and the performance model provides an APU definition, calls the AEIC.emissions.apu.get_APU_emissions function to calculate APU emissions.

5. If GSE emissions are requested, calls the AEIC.emissions.gse.get_GSE_emissions function to calculate GSE emissions.

6. Combines all emissions for each chemical species to produce full trajectory totals.

7. If requested, calculates a lifecycle CO₂ emissions adjustment and applies it to the totals.

8. Collects together all emissions data into a single EmissionsOutput value and returns it.

AEIC.emissions.compute_emissions(pm, fuel, traj)

Compute all emissions. TODO: Expand docstring.

Parameters:

• pm (BasePerformanceModel)

• fuel (Fuel)

• traj (Trajectory)

Return type:

EmissionsOutput

Types

Chemical species

The Species enumerated type lists the chemical species known to AEIC.

enum AEIC.types.Species(value)

Valid values are as follows:

CO2 = <Species.CO2: 1>

H2O = <Species.H2O: 2>

HC = <Species.HC: 3>

CO = <Species.CO: 4>

NOx = <Species.NOx: 5>

NO = <Species.NO: 6>

NO2 = <Species.NO2: 7>

HONO = <Species.HONO: 8>

PMnvol = <Species.PMnvol: 9>

PMnvolGMD = <Species.PMnvolGMD: 10>

PMvol = <Species.PMvol: 11>

OCic = <Species.OCic: 12>

SO2 = <Species.SO2: 13>

SO4 = <Species.SO4: 14>

PMnvolN = <Species.PMnvolN: 15>

Emissions output

The EmissionsOutput class holds emission index and emission quantities for trajectory, LTO, APU, GSE and total emissions, as well as some ancillary quantities like fuel burn per segment. The emission indices and emission quantities are stored as values of the generic type EmissionsDict, with a value type of float (for APU, GSE and total emissions), ModeValues for LTO, and np.ndarray for trajectory emissions. This structure captures the different types of per-species emissions from the different sources.

class AEIC.emissions.emission.EmissionsOutput(trajectory, trajectory_indices, lto, lto_indices, apu, apu_indices, gse, total, fuel_burn_per_segment, total_fuel_burn, lifecycle_co2_g=0.0)

Emissions for a mission broken down by flight phase/components.

Each flight phase/component attribute is a dictionary mapping species to emissions values or indices implemented using the generic EmissionsDict type. These dictionaries contain different types of values depending on the flight phase/component:

• trajectory: NumPy arrays of per-segment emissions [g].

• lto: ModeValues objects containing per-thrust mode emissions [g].

• apu: floats containing total APU emissions [g].

• gse: floats containing total GSE emissions [g].

• total: floats containing total emissions [g].

Parameters:

• trajectory (EmissionsDict[ndarray])

• trajectory_indices (EmissionsDict[ndarray])

• lto (EmissionsDict[ModeValues])

• lto_indices (EmissionsDict[ModeValues])

• apu (EmissionsDict[float])

• apu_indices (EmissionsDict[float])

• gse (EmissionsDict[float])

• total (EmissionsDict[float])

• fuel_burn_per_segment (ndarray)

• total_fuel_burn (float)

• lifecycle_co2_g (float)

apu: EmissionsDict[float]

APU emissions for each species [g].

apu_indices: EmissionsDict[float]

APU emission indices for each species.

fuel_burn_per_segment: ndarray

Fuel burn per trajectory segment [kg].

gse: EmissionsDict[float]

GSE emissions for each species [g].

lifecycle_co2_g: float = 0.0

Lifecycle CO2 emissions adjustment [g].

lto: EmissionsDict[ModeValues]

LTO emissions for each species [g].

lto_indices: EmissionsDict[ModeValues]

LTO emission indices for each species.

property species: set[Species]

Set of species included in any emissions.

total: EmissionsDict[float]

Total emissions for each species [g].

total_fuel_burn: float

Total fuel burn for the mission [kg].

trajectory: EmissionsDict[ndarray]

Per-segment emissions along the trajectory for each species [g].

trajectory_indices: EmissionsDict[ndarray]

Per-segment emission indices along the trajectory for each species.

class AEIC.emissions.emission.EmissionsDict(data=None)

Typed mapping of species to emission values.

Parameters:

data (dict[Species, M] | None)

class AEIC.types.ModeValues(*args, mutable=False)

Specialized dictionary for LTO values keyed by ThrustMode.

Parameters:

mutable (bool)

broadcast(modes)

Broadcast ModeValues to an array according to the provided ThrustModeArray.

Parameters:

modes (ThrustModeArray)

Return type:

ndarray

copy(mutable=None)

Copy a ModeValues dictionary, optionally modifying the mutability. This is the only way to go from an immutable to a mutable instance.

Parameters:

mutable (bool | None)

freeze()

Make a ModeValues dictionary immutable.

Helper functions

AEIC.emissions.trajectory.get_trajectory_emissions(pm, traj, fuel_burn_per_segment, fuel)

Calculate emissions for each flight trajectory point.

Parameters:

• pm (BasePerformanceModel)

• traj (Trajectory)

• fuel_burn_per_segment (np.ndarray)

• fuel (Fuel)

Return type:

EmissionsSubset[np.ndarray]

AEIC.emissions.lto.get_LTO_emissions(performance_model, fuel)

Compute Landing-and-Takeoff cycle emission indices and quantities.

Parameters:

• performance_model (BasePerformanceModel)

• fuel (Fuel)

Return type:

EmissionsSubset[ModeValues]

AEIC.emissions.apu.get_APU_emissions(lto_indices, apu, fuel, apu_time=900)

Calculate APU emissions using time in modes and given APU data.

Parameters:

• APU_emission_indices (ndarray) – self.APU_emission_indices from Emissions class

• APU_emissions_g (ndarray) – self.APU_emissions_g from Emissions class

• lto_indices (ndarray) – self.lto_indices from Emissions class

• apu (dict) – dictionary containing fuel flows and EIs of chosen APU

• LTO_noProp (float) – NOx speciation elements from LTO analysis

• LTO_no2Prop (float) – NOx speciation elements from LTO analysis

• LTO_honoProp (float) – NOx speciation elements from LTO analysis

• apu_time (float) – Time in mode for APU; default value = 900 seconds (Stettler et al. 2011)

• fuel (Fuel)

Returns:

• APU_emission_indices (ndarray) – Emissions indicies for APU

• APU_emissions_g (ndarray) – Emissions in g for APU

• apu_fuel_burn (float) – kg of fuel burnt by APU

Return type:

EmissionsSubset[float]

AEIC.emissions.gse.get_GSE_emissions(aircraft_class, fuel)

Calculate Ground Service Equipment emissions based on aircraft class. Returns emissions dictionary and fuel burn.

Parameters:

• aircraft_class (AircraftClass)

• fuel (Fuel)

Return type:

EmissionsSubset[float]

AEIC.emissions.ei.co2.EI_CO2(fuel)

Calculate carbon-balanced CO2 emissions index (EI).

Parameters:

fuel (Fuel) – Fuel information (input from toml file)

Returns:

CO2_EI – CO2 emissions index [g/kg fuel]

Return type:

float

AEIC.emissions.ei.h2o.EI_H2O(fuel)

Calculate H2O emissions index (EI).

Parameters:

fuel (dictionary) – Fuel information (input from toml file)

Returns:

H2O_EI – H2O emissions index [g/kg fuel]

Return type:

float

AEIC.emissions.ei.sox.EI_SOx(fuel)

Calculate universal SOx emissions indices (SO2EI and SO4EI).

Parameters:

fuel (Mapping[str, Any]) – Fuel information (input from toml file)

Returns:

Structured SO2/SO4 emissions indices [g/kg fuel]

Return type:

SOxEmissionResult

class AEIC.emissions.ei.sox.SOxEmissionResult(EI_SO2, EI_SO4)

Structured SOx emission indices.

Parameters:

• EI_SO2 (float)

• EI_SO4 (float)

AEIC.emissions.ei.hcco.EI_HCCO(ff_eval, x_EI, ff_cal, Tamb=array(3.), Pamb=array(1.5e-323), cruiseCalc=False)

BFFM2 bilinear HC/CO fit to SLS data

Parameters:

• ff_eval (ndarray, shape (n_points,)) – Fuel flows [kg/s] at which to compute xEI. Must be 1D.

• x_EI (ndarray, shape (4,)) – Baseline emission indices [g x / kg fuel] at four calibration fuel‐flow points.

• ff_cal (ndarray, shape (4,)) – Calibration fuel flows [kg/s] corresponding to x_EI

• cruiseCalc (bool) – If True, apply cruise correction (ambient T and P) to the final xEI.

• Tamb (ndarray, shape (n_points,)) – Ambient temperature [K] for cruise correction (if cruiseCalc is True).

• Pamb (ndarray, shape (n_points,)) – Ambient pressure [Pa] for cruise correction (if cruiseCalc is True).

Returns:

xEI – The HC+CO emission index [g x / kg fuel] at each ff_eval.

Return type:

ndarray, shape (n_points,)

class AEIC.emissions.ei.nox.BFFM2EINOxResult(NOxEI, NOEI, NO2EI, HONOEI, noProp, no2Prop, honoProp)

Bundled NOx emissions indices and speciation data.

Parameters:

• NOxEI (ndarray)

• NOEI (ndarray)

• NO2EI (ndarray)

• HONOEI (ndarray)

• noProp (ndarray)

• no2Prop (ndarray)

• honoProp (ndarray)

AEIC.emissions.ei.nox.BFFM2_EINOx(sls_equiv_fuel_flow, EI_NOx_matrix, fuelflow_performance, Tamb, Pamb)

Calculate NOx, NO, NO2, and HONO emission indices All inputs are 1-dimensional arrays of equal length for calibration (fuelflow_KGperS vs. EI_NOx_matrix) and 1-dimensional for SLS_equivalent_fuel_flow (multiple evaluation points).

Parameters:

• fuelflow_trajectory (ndarray, shape (n_times,)) – Fuel flow at which to compute EI.

• EI_NOx_matrix (ndarray, shape (n_cal,)) – Baseline NOx EI values [g NOx / kg fuel] corresponding to calibration fuel flows.

• fuelflow_performance (ndarray, shape (n_cal,)) – Calibration fuel flow values [kg/s] for which EI_NOx_matrix is defined.

• Tamb (float) – Ambient temperature [K].

• Pamb (float) – Ambient pressure [Pa].

• sls_equiv_fuel_flow (ndarray)

Returns:

Structured NOx EI arrays and speciation fractions.

Return type:

BFFM2EINOxResult

class AEIC.emissions.ei.nox.NOXSpeciation(no, no2, hono)

Fractional speciation of NOₓ into NO, NO2, and HONO in different thrust modes.

Parameters:

• no (ModeValues)

• no2 (ModeValues)

• hono (ModeValues)

hono: ModeValues

Fraction of HONO in NOₓ in each thrust mode.

no: ModeValues

Fraction of NO in NOₓ in each thrust mode.

no2: ModeValues

Fraction of NO₂ in NOₓ in each thrust mode.

AEIC.emissions.ei.pmnvol.PMnvol_MEEM(EDB_data, altitudes, Tamb_cruise, Pamb_cruise, machFlight)

Estimate non-volatile particulate matter (nvPM) emissions at cruise using the Mission Emissions Estimation Methodology (MEEM) based on Ahrens et al. (2022), SCOPE11, and the methodology of Peck et al. (2013).

This function computes: - Geometric mean diameter (GMD) of emitted particles - Mass-based emissions index (EI) in g/kg of fuel - Number-based emissions index (EI) in #/kg of fuel

Parameters:

• EDB_data (dict) – EDB data containing engine type, bypass ratio, pressure ratio, smoke number (SN) matrix, and emission indices (mass and number).

• altitudes (ndarray) – Array of flight altitudes [m] over the mission trajectory.

• Tamb_cruise (ndarray) – Ambient temperature [K] at each point in the trajectory.

• Pamb_cruise (ndarray) – Ambient pressure [Pa] at each point in the trajectory.

• machFlight (ndarray) – Mach number at each point in the trajectory.

Returns:

• EI_PMnvol_GMD (ndarray) – Geometric mean diameter of particles [nm], constant along the trajectory.

• EI_PMnvol (ndarray) – Emissions index of non-volatile PM mass [g/kg fuel] along the trajectory.

• EI_PMnvolN (ndarray) – Emissions index of non-volatile PM number [#/kg fuel] along the trajectory.

Notes

• If nvPM_mass_matrix or nvPM_num_matrix is undefined or negative in the EDB_data, this function reconstructs the values using the SN matrix and correlations from the literature.

• Adjustments for altitude and in-flight thermodynamic conditions are made using combustor inlet temperature and pressure estimates derived from ambient conditions and engine pressure ratio.

• Interpolated values account for max thrust EI values where provided.

• Results with invalid SN or negative EI are set to zero with a warning.

AEIC.emissions.ei.pmnvol.calculate_PMnvolEI_scope11(SN_matrix, engine_type, BP_Ratio)

Calculate PM non-volatile Emission Index (EI) using SCOPE11 methodology.

Parameters:

• SN_matrix (ndarray (n x 4)) – Smoke number matrix for each engine and ICAO mode.

• PR (ndarray (n x 4)) – Pressure ratio matrix.

• ENGINE_TYPE (list of str) – Engine types (‘TF’, ‘MTF’, etc.) for each engine.

• BP_Ratio (ndarray (n,)) – Bypass ratio for each engine.

• engine_type (str)

Returns:

PMnvolEI_best_ICAOthrust – Emission index of non-volatile PM mass [g/kg_fuel] for each engine, including 0% thrust extrapolation as first column.

Return type:

ndarray (n x 5)

AEIC.emissions.ei.pmvol.EI_PMvol_FOA3(thrusts, HCEI)

Calculate volatile organic PM emissions index (PMvoloEI) and OC internal EI (OCicEI) using the FOA3.0 method (Wayson et al., 2009).

Parameters:

• thrusts (ndarray, shape (n_types, n_times)) – ICAO thrust settings (%) for each mode and time.

• HCEI (ndarray, shape (n_types, n_times)) – Hydrocarbon emissions index [g/kg fuel] for each mode and time.

Returns:

• PMvoloEI (ndarray, shape (n_types, n_times)) – Emissions index for volatile organic PM [g/kg fuel].

• OCicEI (ndarray, shape (n_types, n_times)) – Same as PMvoloEI (internal organic carbon component).

AEIC.emissions.ei.pmvol.EI_PMvol_FuelFlow(fuelflow, thrustLabel)

Calculate EI(PMvolo) and OCicEI based on fuel flow

Parameters:

• fuelflow (ndarray, shape (n_types, 4)) – Fuel flow factor per type and 4 thrust modes.

• thrustLabel (ThrustLabelArray)

Returns:

• PMvoloEI (ndarray, shape (n_types, 4)) – Emissions index for volatile organic PM [g/kg fuel].

• OCicEI (ndarray, shape (n_types, 4)) – Emissions index for organic carbon internal [g/kg fuel].

AEIC.emissions.lifecycle_CO2.lifecycle_CO2(fuel, fuel_burn)

Calculate lifecycle CO2 emissions.

Parameters:

fuel (dictionary) – Fuel information (input from toml file)

Returns:

lifecycle_CO2

Return type:

float