Struct Aircraft 

pub struct Aircraft { /* private fields */ }

The aircraft we’re planning to fly with.

This aircraft provides all information necessary to execute the fuel and mass & balance planning. The aircraft is created in it’s empty configuration. All additional mass are loaded at a Station that places the mass at a fixed distance from a reference datum (the arm). The aircraft is created only with the station arms and mass is mapped to the stations when doing the mass & balance calculation. Stations that account for the mass of fuel are derived from the tanks and fuel consumption.

The aircraft’s mass & balance is calculated by mb for mass and fuel at ramp and after landing. There are further methods to calculate the mass & balance based on simplifications like constant mass during flight or equal fuel distribution across all tanks.

Examples

This is how a C172 of our flying club with a Diesel engine would look like:

let ac = Aircraft::builder()
    .registration("N12345".to_string())
    .icao_type("C172".to_string())
    .stations(vec![
        Station::new(Length::m(0.94), Some("front seats".to_string())),
        Station::new(Length::m(1.85), Some("back seats".to_string())),
        Station::new(Length::m(2.41), Some("first cargo compartment".to_string())),
        Station::new(Length::m(3.12), Some("second cargo compartment".to_string())),
    ])
    .empty_mass(Mass::kg(807.0))
    .empty_balance(Length::m(1.0))
    .fuel_type(FuelType::Diesel)
    .tanks(vec![
        FuelTank::new(Volume::l(168.8), Length::m(1.22)),
    ])
    .cg_envelope(vec![
        CGLimit::new(Mass::kg(0.0), Length::m(0.89)),
        CGLimit::new(Mass::kg(885.0), Length::m(0.89)),
        CGLimit::new(Mass::kg(1111.0), Length::m(1.02)),
        CGLimit::new(Mass::kg(1111.0), Length::m(1.20)),
        CGLimit::new(Mass::kg(0.0), Length::m(1.20)),
    ])
    .build()
    .unwrap();

// now we can calculate the mass & balance for a flight with one pilot on
// board and 20 Liter fuel consumption that is distributed equally across
// all tanks
let mb = ac.mb_from_const_mass_and_equally_distributed_fuel(
    &vec![
        // we're in the front
        Mass::kg(80.0),
        // and no mass on the other stations
        Mass::kg(0.0),
        Mass::kg(0.0),
        Mass::kg(0.0)
    ],
    // we start our flight with 80 Liter of Diesel
    &diesel!(Volume::l(80.0)),
    // and land with 60 Liter remaining in our tank
    &diesel!(Volume::l(60.0)),
);

// finally we can check if the aircraft is balanced throughout the flight
assert!(ac.is_balanced(&mb.unwrap()));

Implementations

impl Aircraft

pub fn builder() -> AircraftBuilder

Returns a builder to build an aircraft.

Examples found in repository

examples/flightplanner.rs (line 116)

fn main() -> Result<()> {
    // Performance setting with 65% load in cruise. This is the performance
    // profile of a Cessna C172 with an TAE125-02-114 Diesel engine.
    let perf = Performance::from_fn(
        |vd| {
            let tas = if *vd >= VerticalDistance::Altitude(10000) {
                Speed::kt(114.0)
            } else if *vd >= VerticalDistance::Altitude(8000) {
                Speed::kt(112.0)
            } else if *vd >= VerticalDistance::Altitude(6000) {
                Speed::kt(110.0)
            } else if *vd >= VerticalDistance::Altitude(4000) {
                Speed::kt(109.0)
            } else {
                Speed::kt(107.0)
            };

            let ff = FuelFlow::PerHour(diesel!(Volume::l(21.0)));

            (tas, ff)
        },
        // The data end at 10000 ft so we don't need to create the Performance
        // with more values.
        VerticalDistance::Altitude(10000),
    );

    let takeoff_perf = TakeoffLandingPerformance::builder(vec![
        (
            VerticalDistance::PressureAltitude(0),
            Temperature::c(0.0),
            Length::ft(845.0),
            Length::ft(1510.0),
        ),
        (
            VerticalDistance::PressureAltitude(0),
            Temperature::c(10.0),
            Length::ft(910.0),
            Length::ft(1625.0),
        ),
        (
            VerticalDistance::PressureAltitude(0),
            Temperature::c(20.0),
            Length::ft(980.0),
            Length::ft(1745.0),
        ),
        (
            VerticalDistance::PressureAltitude(0),
            Temperature::c(30.0),
            Length::ft(1055.0),
            Length::ft(1875.0),
        ),
        (
            VerticalDistance::PressureAltitude(0),
            Temperature::c(40.0),
            Length::ft(1135.0),
            Length::ft(2015.0),
        ),
    ])
    .factors(vec![
        // Decrease distances 10% for each 9 knots headwind. For operation
        // with tail winds up to 10 knots, increase distances by 10% for
        // each 2 knots.
        AlteringFactor::DecreaseHeadwind(FactorOfEffect::Rate {
            numerator: 0.1,
            denominator: Speed::kt(9.0),
        }),
        AlteringFactor::IncreaseTailwind(FactorOfEffect::Rate {
            numerator: 0.1,
            denominator: Speed::kt(2.0),
        }),
        // For operation on dry, grass runway, increase distances by 15% of
        // the "ground roll" figure.
        AlteringFactor::IncreaseRWYCC(HashMap::from([
            ((None, Some(RunwaySurface::Grass)), 0.15), // we'll add 15% on any grass
        ])),
    ])
    .build();

    let aircraft = Aircraft::builder()
        .registration("N12345".to_string())
        .stations(vec![
            Station::new(Length::m(0.94), Some(String::from("front seats"))),
            Station::new(Length::m(1.85), Some(String::from("back seats"))),
            Station::new(
                Length::m(2.41),
                Some(String::from("first cargo compartment")),
            ),
            Station::new(
                Length::m(3.12),
                Some(String::from("second cargo compartment")),
            ),
        ])
        .empty_mass(Mass::kg(807.0))
        .empty_balance(Length::m(1.0))
        .fuel_type(FuelType::Diesel)
        .tanks(vec![FuelTank::new(Volume::l(168.8), Length::m(1.22))])
        .cg_envelope(vec![
            CGLimit::new(Mass::kg(0.0), Length::m(0.89)),
            CGLimit::new(Mass::kg(885.0), Length::m(0.89)),
            CGLimit::new(Mass::kg(1111.0), Length::m(1.02)),
            CGLimit::new(Mass::kg(1111.0), Length::m(1.20)),
            CGLimit::new(Mass::kg(0.0), Length::m(1.20)),
        ])
        .build()
        .expect("all required aircraft parameter should be configured");

    let mut fms = FMS::new();

    // read the ARINC database
    let ed_nd = NavigationData::try_from_arinc424(ARINC_424_RECORDS)?;

    fms.modify_nd(|nd| nd.append(ed_nd))?;

    // decode a route from EDDH to EDHF with winds at 20 kt from 290° and
    // cruising speed of 107 kt and an altitude of 2500 ft. Takeoff runway in
    // EDDH is runway 33 and landing runway in EDHF is 20.
    fms.decode("29020KT N0107 A0250 EDDH33 N2 N1 DCT EDHF20".to_string())?;

    // Now we can enter some data into the flight planning to get a fuel planning
    // and mass & balance calculation.
    let mut builder = FlightPlanning::builder();

    builder
        .aircraft(aircraft)
        .mass(vec![
            // we're in the front
            Mass::kg(80.0),
            // and no mass on the other stations
            Mass::kg(0.0),
            Mass::kg(0.0),
            Mass::kg(0.0),
        ])
        .policy(FuelPolicy::ManualFuel(diesel!(Volume::l(80.0))))
        .taxi(diesel!(Volume::l(10.0)))
        .reserve(Reserve::Manual(Duration::s(1800))) // 30 min
        .perf(perf)
        .takeoff_perf(takeoff_perf)
        // we use the route's wind so no need to specify it here
        .origin_rwycc(RunwayConditionCode::Six)
        .origin_temperature(Temperature::c(20.0));

    fms.set_flight_planning(builder)?;

    println!("{}", fms.print(40));

    Ok(())
}

pub fn registration(&self) -> &str

The unique registration code of the aircraft aka tail number.

pub fn icao_type(&self) -> &str

The aircraft type designator according to ICAO Doc. 8643.

pub fn stations(&self) -> &[Station]

The distances from a reference datum at which mass can be loaded e.g. the position of a seat.

pub fn empty_mass(&self) -> &Mass

The mass of the empty aircraft taken from the last mass and balance report.

pub fn empty_balance(&self) -> &Length

The center of gravity of the empty aircraft taken from the last mass and balance report.

pub fn fuel_type(&self) -> &FuelType

The aircraft’s fuel type.

pub fn tanks(&self) -> &[FuelTank]

The fuel tanks with their usable capacity.

pub fn cg_envelope(&self) -> &CGEnvelope

The center of gravity envelope which must contains the CG at a mass for the aircraft to be balanced.

pub fn notes(&self) -> Option<&str>

Notes regarding the aircraft e.g. when the empty mass and balance were determined.

pub fn usable_fuel(&self) -> Option<Fuel>

Returns the usable fuel.

The usable fuel is the sum of all tank capacities with the aircraft’s fuel type or None if no tank is defined.

pub fn is_balanced(&self, mb: &MassAndBalance) -> bool

Tests if the mass & balance is within the aircraft’s CGEnvelope.

pub fn mb( &self, mass_on_ramp: &[Mass], mass_after_landing: &[Mass], fuel_on_ramp: &[Fuel], fuel_after_landing: &[Fuel], ) -> Result<MassAndBalance, Error>

Returns the mass & balance on ramp and after landing.

The mass vectors are mapped to the station arms by position e.g. the mass at index 0 is placed at the station arm at index 0. Thus, the length of the mass vectors must match the length of the station arms. The same goes for the fuel, however the fuel vectors are mapped to the tanks.

Errors

If the length of any mass vector doesn’t match the length of the station arms or the length of any fuel vector doesn’t match the tanks length, an error is returned.

pub fn mb_from_equally_distributed_fuel( &self, mass_on_ramp: &[Mass], mass_after_landing: &[Mass], on_ramp: &Fuel, after_landing: &Fuel, ) -> Result<MassAndBalance, Error>

pub fn mb_from_const_mass_and_equally_distributed_fuel( &self, mass: &[Mass], on_ramp: &Fuel, after_landing: &Fuel, ) -> Result<MassAndBalance, Error>

Trait Implementations

impl Clone for Aircraft

fn clone(&self) -> Aircraft

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Aircraft

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Aircraft

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Aircraft

fn eq(&self, other: &Aircraft) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Aircraft

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Aircraft

impl StructuralPartialEq for Aircraft