Struct FlightRow 

pub struct FlightRow {

    pub id: String,
    pub title: String,
    pub design: String,
    pub source: String,
    pub files: Vec<FileRead>,
    pub weather_time_utc: String,
    pub log_rows: usize,
    pub log_until_s: Option<f64>,
    pub altimeter: String,
    pub altimeter_evidence: String,
    pub log_apogee_m: f64,
    pub hpr_apogee_m: f64,
    pub hpr_height_apogee_m: f64,
    pub apogee_error_percent: f64,
    pub log_time_to_apogee_s: f64,
    pub hpr_time_to_apogee_s: f64,
    pub trace_rms_m: f64,
    pub trace_rms_percent: f64,
    pub hpr_max_mach: f64,
    pub trace_rows: usize,
    pub total_impulse_ns: f64,
    pub negative_thrust_zeroed_ns: f64,
    pub example_drag_source: String,
    pub example_drag_apogee_m: f64,
    pub example_drag_apogee_error_percent: f64,
    pub example_drag_trace_rms_m: f64,
    pub recorded_thrust: Option<RecordedThrust>,
    pub pressure_reading_max_m: Option<f64>,
    pub gnss_apogee_m: Option<f64>,
    pub inputs_sha256: String,
    pub note: String,
    pub explanation_kind: String,
    pub explanation: String,
}

One flight’s result, as the report keeps it.

Fields

id: String

The flight’s id.

title: String

The rocket, team and event.

design: String

The design flown.

source: String

The notebook lines the inputs come from.

files: Vec<FileRead>

The log, the thrust file, the weather file and the design, with their digests.

weather_time_utc: String

The launch time the weather is read at, UTC, ISO 8601.

log_rows: usize

The log’s rows read.

log_until_s: Option<f64>

The time past which the log is not read, s (Log::until_s).

altimeter: String

What measured the log’s height (Altimeter::kind).

altimeter_evidence: String

Where that comes from.

log_apogee_m: f64

The log’s apogee: its highest reading, m.

hpr_apogee_m: f64

hpr’s apogee as the log’s altimeter would read it, m: above its center of mass’s starting height, or for a barometric log, the pressure altitude of the ERA5 pressure there less the start’s.

hpr_height_apogee_m: f64

hpr’s apogee above its center of mass’s starting height, m, whatever the altimeter.

apogee_error_percent: f64

hpr’s less the log’s, per cent of the log’s.

log_time_to_apogee_s: f64

The time from the alignment height to apogee in the log, s.

hpr_time_to_apogee_s: f64

The same in hpr, s.

trace_rms_m: f64

The RMS of hpr’s heights less the log’s over the ascent, m.

trace_rms_percent: f64

That RMS as a percentage of the log’s apogee.

hpr_max_mach: f64

hpr’s largest Mach number over the flight compared, in the ERA5 air: what the accuracy census classes the flight’s speed by (subsonic below 0.8, supersonic above 1.2).

trace_rows: usize

The log rows the RMS is over.

total_impulse_ns: f64

The thrust hpr flew, as a total impulse, N s.

negative_thrust_zeroed_ns: f64

The impulse added by reading the thrust file’s negative points as zero, N s.

example_drag_source: String

Where the example’s drag comes from.

example_drag_apogee_m: f64

hpr’s apogee on the example’s drag, m.

example_drag_apogee_error_percent: f64

Its error against the log’s, per cent.

example_drag_trace_rms_m: f64

Its trace RMS against the log’s, m.

recorded_thrust: Option<RecordedThrust>

For an example that reshapes its thrust file, the second diagnostic: the file flown as recorded.

pressure_reading_max_m: Option<f64>

For a log that keeps its pressure: the largest gap between its height column and the standard atmosphere’s reading of that pressure less the first row’s, over the rows read, m.

gnss_apogee_m: Option<f64>

For a flight that logged a satellite altitude: its highest above its first row, m.

inputs_sha256: String

The SHA-256 of the flight’s entry in FLIGHTS as Rust’s Debug prints it: every input the code gives it, so CI sees a changed one. Debug output may change with a Rust release; CI then flags every row, and cargo xtask real-flights rewrites them.

note: String

What departs from the day, in words.

explanation_kind: String

What the explanation claims (Explanation::kind), empty when there is none.

explanation: String

Why the apogee misses by more than the target, when it does.

Trait Implementations

impl Clone for FlightRow

fn clone(&self) -> FlightRow

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FlightRow

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FlightRow

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for FlightRow

fn eq(&self, other: &FlightRow) -> 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 FlightRow

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for FlightRow