Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Reading a flight log

Read an altimeter’s flight log with FusionSpace HPR’s analyzer to learn how high your rocket went, how fast it climbed and when it landed.

This page is for anyone with an altimeter’s log who wants to know what their rocket did. FusionSpace HPR · Analyzer reads the log on its own. It needs no design file and runs no simulation. So it works whatever the rocket was designed in, or if it was never designed on a computer at all.

What works today: logs from PerfectFlite altimeters in their .pf2 format, the Pnut’s, the StratoLogger’s and the StratoLoggerCF’s (the format). The library also reads these (the layouts read):

  • PerfectFlite’s CSV and text exports
  • AltOS’s CSV
  • the Featherweight Raven’s FIP CSV
  • the Blue Raven’s CSV
  • the RRC3’s and Eggtimer’s (and an Eggtimer TRS’s terminal text)
  • PerfectFlite’s .pfa
  • AltimeterCloud’s and Entacore AIM’s CSV
  • AerospaceNU’s SillyGoose logs and its flight computer board’s CSV and ground station text
  • Silicdyne Fluctus’s CSV
  • the ARTS2’s interpreted data
  • a phone app’s launch CSV
  • an Eggtimer’s download saved as RTF
  • the Raven’s .FIPa and the RRC3’s .rff raw downloads
  • the Featherweight app’s flight summaries (figures, no samples)
  • the R-DAS’s raw text (its counts kept as written)
  • AltOS’s radio telemetry and its .eeprom raw downloads
  • the ARTS2’s .odf and raw CSV
  • GPS tracks from Featherweight’s GPS tracker, KML and NMEA files, and Missile Works’ RTx tracker’s .rtx file and its exports
  • GPS tracks in GPX files, checked on invented files only (the evidence register’s row on GPX)
  • tables from loggers no other reader knows, by the units their headers state, into the same record
  • those tables in a CSV layout also from the sheets of an Excel workbook
  • a team flight computer’s binary records, by a layout the caller states
  • a Blue Raven’s USB download, each line held to its CRC
  • a course’s Teensy data logger, its units held to the flight’s physics
  • one team’s radio telemetry packets, 255:…:254
  • a Raven FIP export pasted below no header, under a header you state
  • an AltiMAX altimeter’s .xls export and its own .ALS file
  • Entacore AIM’s .xtra files and raw dumps
  • a MARSA altimeter’s download
  • AltOS’s radio telemetry decoded to a table
  • AltOS’s CSV re-saved by a spreadsheet, its formulas kept as text, or cut to its columns
  • tables whose headers state too little, by a column mapping you state; the sample tables’ mappings each hold every unit to a physical check

hpr analyze and Python read each layout the library tells from the file alone, each by its own reader. They read one sheet of a workbook or one recording of a raw dump at a time (below). They read a table or binary records by a column mapping or a record layout (Reading your own logger). A zip archive’s files must be unpacked first.

Since readings on every logger shipped, they come from any logger’s barometric altitude or pressure, each within a stated bound. A GPS track gives none. Since the rest of the readings shipped, they include burnout, the flight time and each canopy’s descent rate. They also include the top acceleration from an accelerometer along the rocket’s axis. Formats no sample holds yet, such as a CATS flight computer’s, are listed as needing samples (the evidence row on these formats).

One real flight’s log is public, but it isn’t committed here, so it isn’t checked in CI. On it, the analyzer reads the apogee as 1,009 ft above the pad, as the altimeter states it. Those are two readings of one pressure trace, not a measurement of the height (the analyzer’s evidence row).

Most of an apogee’s bound is the day’s air. A barometric altimeter turns pressure into height by the standard atmosphere. So on a day 15 K from standard, its heights are off by up to 6.92%. Standard air is 15 °C less 6.5 °C a kilometer of height. So 15 K over is 30 °C (86 °F) at a sea-level field, and about 22 °C (72 °F) at a 1,190 m (3,904 ft) one. Past that, the bound may not hold. The log may record the pad’s temperature and its height above sea level: from its pressure, an altitude above sea level, or a stated ground elevation. Then hpr analyze says so beside each reading the day moves (A hot or cold day).

The top speed is worked out from the heights. It’s withheld from 227.7 m/s (747 ft/s), Mach 0.8 in the coldest air the bounds allow (the top speed). At those speeds a barometer’s port may read the flow over the nose.

The known gaps, each an open issue, are listed under What it doesn’t do yet. For a record or a certification, the altimeter’s own reading is the one to log. The rules behind each reading are on Flight-log readings, with what they were checked against. A reading the log can’t support is left out and says why, rather than printed as a number.

From the command line

hpr analyze flight.pf2

reads any layout the library tells from the file alone. It prints the readings as text, each with the bound its error stays within (“within …”), or as one JSON document with --json. hpr analyze shows its output on an example log, and its JSON schema lists the fields.

Another logger’s table is read by a column mapping, --mapping, and its binary records by a record layout, --layout. Each is a JSON file you write. Reading your own logger works through both on an invented logger.

A file of several records

A spreadsheet’s workbook holds sheets. The workbook is an .xlsx, or an .xls written as one bare worksheet (as an AltiMAX altimeter’s Excel export is). An Entacore AIM raw dump can hold several recordings.

hpr analyze reads one at a time, each by its own reader. With no choice given, it reads the workbook’s one sheet that reads as a log, or the dump’s one recording. Where there are several, or no sheet reads, it refuses and names them, a sheet by its number and name, such as 2 (Second). Choose one, counted from 0:

hpr analyze flight.xlsx --sheet 2
hpr analyze flight.dump --recording 1

From Python, FlightLog.read(path, sheet=2) and FlightLog.read(path, recording=1) do the same. A Featherweight Raven’s FIP export that lost its header line when it was pasted into a workbook reads too. It’s read under a header you state, --fip-header (Reading your own logger).

From a program

The library is hpr_flightdata. It reads a log’s text into a record in SI units, then takes the readings from that record. It doesn’t depend on the simulator, so a program that only reads logs doesn’t build one. This program reads the invented log the tests use, and prints each reading’s value and where it came from. Each reading also carries its bound, as hpr analyze prints it:

//! A flight log read on its own: the invented PerfectFlite log the tests use, its readings printed
//! with where each came from, or why it was withheld. No design file, no simulation.
//!
//! It uses the workspace crate `hpr-flightdata`, which doesn't pull in the simulator, and `serde`
//! and `serde_json` to print each code as the JSON output spells it.
//!
//! Run it from anywhere in the repository:
//!
//! ```text
//! cargo run --example read_a_log -p fusionspace-hpr-flightdata
//! ```
//!
//! The guide's page *Reading a flight log* (`docs/reading-a-flight-log.md`) quotes it and what it
//! prints, which is kept next to it in `read_a_log.output.txt`; CI checks that the two still agree
//! (`cargo xtask examples --check`).

#![allow(
    clippy::print_stdout,
    reason = "the project's lints forbid printing in library code, and this program exists to print"
)]

use std::error::Error;

use hpr_flightdata::perfectflite::{self, FOOT_M};
use hpr_flightdata::readings::{self, Reading};

/// The invented log: a Pnut's file of a flight made up for the tests.
const LOG: &str = include_str!("../../../validation/fixtures/logs/synthetic-pnut.pf2");

/// A code as the JSON output spells it, such as `no_accelerometer`.
fn code(value: impl serde::Serialize) -> String {
    serde_json::to_value(value)
        .ok()
        .and_then(|json| json.as_str().map(str::to_owned))
        .unwrap_or_default()
}

/// A reading's value as text, or why it was withheld.
fn show<T>(reading: &Reading<T>, value: impl Fn(&T) -> String) -> String {
    match reading {
        Reading::Read(read) => value(read),
        Reading::Withheld(withheld) => {
            format!("withheld ({}): {}", code(withheld.reason), withheld.detail)
        }
    }
}

fn main() -> Result<(), Box<dyn Error>> {
    let log = perfectflite::read(LOG)?;
    println!("{}: {} samples", log.logger, log.time_s.len());
    if let Some(stated) = log.stated.apogee_m {
        println!("it states an apogee of {:.0} ft", stated / FOOT_M);
    }

    let read = readings::read(&log);
    println!();
    println!(
        "liftoff           {}",
        show(&read.liftoff, |liftoff| format!("{:.2} s", liftoff.time_s))
    );
    println!(
        "apogee            {}",
        show(&read.apogee, |apogee| format!(
            "{:.1} m ({:.0} ft) at {:.2} s, source: {}",
            apogee.altitude_m,
            apogee.altitude_m / FOOT_M,
            apogee.time_s,
            code(apogee.source)
        ))
    );
    println!(
        "highest sample    {}",
        show(&read.apogee, |apogee| format!(
            "{:.1} m at {:.2} s",
            apogee.highest_sample.altitude_m, apogee.highest_sample.time_s
        ))
    );
    println!(
        "top speed         {}",
        show(&read.max_speed, |speed| format!(
            "{:.1} m/s at {:.2} s, source: {}",
            speed.speed_m_s,
            speed.time_s,
            code(speed.source)
        ))
    );
    println!(
        "top acceleration  {}",
        show(&read.max_acceleration, |top| format!(
            "{:.1} m/s²",
            top.acceleration_m_s2
        ))
    );
    println!(
        "burnout           {}",
        show(&read.burnout, |burnout| if burnout.is_floor {
            // A floor: the pair printed is the reading and its bound, and the floor, their
            // difference, is the soonest burnout can have come.
            format!(
                "no sooner than {:.2} s less {:.2} s, source: {}",
                burnout.time_s,
                burnout.bound_s,
                code(burnout.source)
            )
        } else {
            format!("{:.2} s, source: {}", burnout.time_s, code(burnout.source))
        })
    );
    println!(
        "landing           {}",
        show(&read.landing, |landing| format!(
            "{:.2} s; down from apogee at {:.1} m/s on average",
            landing.time_s, landing.mean_descent_rate_m_s
        ))
    );
    println!(
        "flight time       {}",
        show(&read.flight_time, |flight| format!(
            "{:.2} s",
            flight.time_s
        ))
    );
    println!(
        "drogue            {}",
        show(&read.drogue_descent, |leg| format!(
            "{:.1} m/s",
            leg.rate_m_s
        ))
    );
    println!(
        "main              {}",
        show(&read.main_descent, |leg| match &leg.opening {
            Some(opening) => format!(
                "{:.1} m/s, opened at {:.2} s, {:.0} m up",
                leg.rate_m_s, opening.time_s, opening.height_m
            ),
            None => format!("{:.1} m/s", leg.rate_m_s),
        })
    );
    Ok(())
}

It prints:

PerfectFlite Pnut: 984 samples
it states an apogee of 1281 ft

liftoff           0.80 s
apogee            390.1 m (1280 ft) at 10.28 s, source: barometer
highest sample    400.5 m at 11.35 s
top speed         78.3 m/s at 2.20 s, source: barometer
top acceleration  withheld (no_accelerometer): the log has no accelerometer; HPR Sim doesn't difference a height twice to make one, as its steps would read as spikes of many g
burnout           no sooner than 2.20 s less 1.32 s, source: barometer
landing           45.80 s; down from apogee at 10.9 m/s on average
flight time       45.00 s
drogue            21.7 m/s
main              6.0 m/s, opened at 21.40 s, 148 m up

What the readings say

The log is of a flight invented for the tests (the flight). It reaches 80 m/s (262 ft/s) at burnout, 2.1 s after the start of the log. Then it coasts with no drag to 390.3 m (1,280.5 ft) at 10.26 s. Each bound below is the one hpr analyze prints for the same log. A bound’s feet are converted exactly here, where hpr analyze rounds them up: the drogue’s bound below reads 7.2 ft/s here and 8 ft/s there.

  • Liftoff, 0.80 s, within 0.81 s: the last sample before the altitude climbs out of the pad’s noise allowance. The allowance is at least 2 m (6.6 ft) and a step. The rocket left the pad at 0.50 s; it took 0.30 s to climb that far.

  • Apogee, 390.1 m (1,280 ft) at 10.28 s, which is 10.275 s rounded. The top is flat over several samples, so the analyzer takes their middle as its time. It’s the top of the altitude after a 0.3 s running median. It’s 0.17 m (0.56 ft) below the true apogee, well within its 31.9 m (105 ft) bound.

  • The highest sample, 400.5 m (1,314 ft), a second after apogee, is the ejection charge’s pressure pulse, not the rocket. The median sets it aside.

  • The top speed, 78.3 m/s (257 ft/s) at 2.20 s, within 20.6 m/s (68 ft/s). It’s worked out from the heights, as the steepest slope of a 0.5 s fit, not read from the altimeter’s speed column. The true speed at burnout is 80.0 m/s (262.5 ft/s); the fit across the corner at burnout reads it a little low.

  • The top acceleration is withheld: a PerfectFlite has no accelerometer. HPR Sim doesn’t difference the heights twice to make one, as their one-foot steps would read as spikes of many g.

  • Burnout, no sooner than 0.88 s: the top speed’s time, 2.20 s, less its 1.32 s bound. With no accelerometer, burnout is a floor: its reading is the top speed’s time, and the floor that time less its bound. A rocket gains speed only while its thrust beats the drag and its weight. So the motor burned out no sooner than the floor. It may have burned on after the top speed’s time by any amount. The true burnout is 2.10 s.

    The floor is loose by design: on the synthetic flights’ tuning set, the top speed came 0.24 s before the true burnout on average. The top speed’s time ranged from 1.03 s before the true burnout to 0.718 s after it. The floor lies its bound, about 1.3 s, earlier still (Checked against).

  • Landing, 45.80 s, within 2.11 s: the first sample back within the pad’s allowance. The rocket touches down 0.34 s later, at 6 m/s (20 ft/s) under its main.

  • The flight time, 45.00 s, within 2.91 s: landing’s time less liftoff’s. The true flight time is 45.64 s: liftoff is read 0.30 s late and landing 0.34 s early.

  • The mean descent rate, 10.9 m/s (36 ft/s), within 2.1 m/s (6.9 ft/s). It’s the height lost from apogee to landing over the time taken, drogue and main together.

  • The drogue’s descent, 21.7 m/s (71 ft/s), within 2.2 m/s (7.2 ft/s), from apogee at 10.28 s to the main’s opening at 21.40 s. It is the mean rate from apogee, as hpr analyze says on its line: the height lost over the time taken, so the fall from rest there is included. The rocket fell under its drogue at 25 m/s (82 ft/s), but started that leg from rest. Over the same span, the leg’s true rate is 21.74 m/s (71.3 ft/s).

  • The main’s descent, 6.0 m/s (20 ft/s), within 0.8 m/s (2.6 ft/s), from its opening to landing, as the flight’s main truly fell. The opening is at 21.40 s within 1.06 s, 148.4 m (487 ft) up. It’s found by walking back from landing until the descent’s rate climbs well past the main’s. The main truly opened at 21.14 s, 150 m (492 ft) up, so the reading is 0.26 s late. It’s late because the rate, a slope fitted over 1 s, still sees some of the drogue’s faster fall just after the opening.

What the file states about itself, such as the altimeter’s own apogee of 1,281 ft, is kept in log.stated. It sits beside the analyzer’s readings, never in their place.

The codes, such as no_accelerometer and barometer, are the ones the JSON output of hpr analyze uses. The top speed is max_speed in both, the top acceleration max_acceleration, and the canopies’ legs drogue_descent and main_descent. A reading that is a floor carries is_floor, and a clipped top acceleration says why in clip, range or flat. Python’s FlightLog.readings() returns the same readings, bounds included, as a dict (From Python).

Every code a reading can be withheld with is in the table of reasons, with when it applies. Among them are those that came with the accelerometer and the canopies:

  • axis_unstated (no accelerometer named along the rocket)
  • gravity_unstated (whether its readings hold gravity)
  • direction_unstated (which way up it reads)
  • one_canopy (no drogue’s leg in the descent)
  • short_leg (a leg too short to read)

A hot or cold day

Each bound allows for air up to 15 K from the standard atmosphere. That is 30 °C (86 °F) at a sea-level field, and about 22 °C (72 °F) at a 1,190 m (3,904 ft) one. Past that, the bound may not hold. On a hot day a barometric altimeter reads its heights low, and with them the top speed and the descent rates. On a cold day it reads them high.

hpr analyze checks the day where it can. It compares the log’s temperature on the pad with the standard atmosphere’s at the pad’s height above sea level (A day past 15 K). That height comes from a pressure column, an altitude above sea level, or the ground elevation the logger states. Past 15 K, a line above the readings gives the log’s temperature and the offset. Below the apogee, the top speed, the mean descent rate and each canopy’s rate, a note gives how far the day’s air alone may put the true value from the reading:

the day's air may put the true height up to 289.2 m (949 ft) above the reading, 10.6%, where the bound allows 6.9% for the day's air

That figure is from the worked example on the physics page, not a real log. Its “up to” assumes the pad’s offset from the standard holds up the climb; under an inversion the day’s air can move the reading more. On a low flight, a day just past 15 K can move a reading by less than the bound’s 6.92%. The note then says the day is past 15 K, but within the bound’s share at this flight’s height. What to do then:

  1. Check the temperature. A logger’s temperature is often the electronics bay’s, warmed by the sun and the electronics. Take the field’s own weather reading at launch time. Subtract the standard’s at the field’s height, 15 °C less 6.5 °C a kilometer: 7.3 °C (45.1 °F) at 1,190 m (3,904 ft). If that is within 15 K, the pad’s reading suggests the day’s-air part of the bounds holds; the air aloft isn’t measured.
  2. If the air was past 15 K, the bound may not cover the day. Call the note’s share less 6.92% (if positive) its extra share. If the pad’s offset holds up the climb, the extra share is the most the day’s air may add beyond the bound, on the side the note names. In the example that is 10.561% less 6.924%, 3.637% of 2,738 m (8,983 ft): 99.6 m (327 ft). It is not a validated bound, and it can understate. A morning inversion leaves the air near the ground cooler than the air above it. A hot pad’s offset then grows up the climb, and the day’s air can move the reading more. The 90% interval isn’t validated past 15 K. A waiver, a record or a safety figure may rest on the reading. Then move the reading by its bound and by the extra share, the way the note gives. That is above the reading on a hot day, below it on a cold one. Show the note with that figure, and leave the call to the RSO and the safety code.
  3. For the descent rates, the same holds. A hot day’s true rate is faster than the reading, a cold day’s slower. Move the rate by its bound and by the note’s extra share, the way the note gives: above the reading on a hot day, below it on a cold one. Show the note with that rate, and leave the call on the recovery to the RSO and the safety code.

A log with no temperature, or with no pressure, no altitude above sea level and no stated ground elevation, gets no check. Nor does a temperature outside −100 to 100 °C. Nor does a temperature column of one value throughout at a unit’s zero (0 K, 0 °C or 0 °F), as a logger with no sensor writes. Nothing then tells you the day was within 15 K, so check the day’s temperature at the field yourself. The text output is silent both when the day is within 15 K and when there was no check. --json’s day_air tells them apart: null means no check.

The 90% intervals and the health card

Beside its bound, a reading may give a 90% interval: where the truth lay nine times in ten on the synthetic flights. No real flight has checked one (evidence row G34). The bound is the size every error stayed within on the tuning set, and the one to use for a waiver or a load, unless the reading is a floor, which has no upper figure. A burnout floor or a clipped top acceleration gives a “95% lower end” in its place: about 19 truths in 20 lay above it. An apogee or top speed floor gives neither.

An interval can lie wholly to one side of its reading, as the reading’s error leans one way. Liftoff is read late, so its interval lies earlier (0.80 s, interval 0.41 to 0.64 s). The flight time, landing less liftoff, reads short, so its interval lies later (45.00 s, interval 45.38 to 46.11 s).

The last rows are the smoother’s, every sensor together, also unchecked on a real flight (evidence row G33). Its apogee is a cross-check: report the reading. Its health card says how each sensor fared. It can say the pad was assumed, as on a log that starts at launch, or the accelerometer set aside. Neither asks anything of you, though the track then rests on less. If it says the smoothed apogee is past the reading’s bound, go by the reading.

Two logs of one flight

Fly two altimeters and you have two logs, each counting from a zero of its own: when the board was switched on, or when it saw the boost. Give hpr analyze both and it puts them on one timeline:

hpr analyze one.csv two.csv

It lines the clocks up by a shared liftoff: every board in a rocket leaves the pad at the same instant, so the time from one log’s liftoff to the other’s is the offset between their clocks. Each log keeps its own readings. They are never averaged, because two boards are two measurements, and each reading’s spread, the largest less the least, says how far apart they lie, not which is right. Two boards can agree and both be off by the day’s air. A log that ends on the climb gives floors for its top height and top speed, each without an interval, and a floor joins no spread. Nothing checks that the two logs are of one flight: that’s your word.

The offset’s bound is the sum of the two liftoffs’ bounds, and it held on every one of the 1,383 offsets the two-logger synthetic flights gave, the largest error 0.21 s and the median 0.03 s. Its 90% interval passed the same test as the readings’ (the report).

One real flight checks it against another clock, though not hard (evidence row G35). RocketPy’s Prometheus flight carried a TeleMetrum and a TeleMega, each with its own GPS receiver:

ReadingTeleMetrumTeleMegaSpread
Apogee, above its own pad3,892.1 m (12,769 ft)3,894.7 m (12,778 ft)2.6 m (9 ft)
Smoothed apogee3,985.7 m (13,076 ft)4,015.4 m (13,174 ft)29.7 m (98 ft)
Flight time223.01 s222.83 s0.18 s
Under the drogue26.5 m/s (87 ft/s)26.5 m/s (87 ft/s)0.0 m/s (0 ft/s)
Under the main6.5 m/s (21 ft/s)6.5 m/s (21 ft/s)0.0 m/s (0 ft/s)

Their liftoffs read 0.23 s and 0.18 s, each on its own clock. The TeleMega’s clock less the TeleMetrum’s comes to −0.05 s, within 1.53 s, 90% interval −0.13 to 0.04 s. The two receivers’ UTC seconds, taken where each second ticks in each log, put it at −0.13 s: the ticks stay within about 0.02 s of that where the logs run at 100 samples a second, and any fixed difference between the receivers’ delays can’t be seen. So this offset is about 0.08 s away, and the interval’s low end, −0.129 s unrounded, is too close to that figure to say which side it falls. Both logs start at the boost, so their clocks hardly differ: an offset of zero would miss by 0.13 s, against this offset’s 0.08 s. That’s one flight: it can’t show whether the interval holds nine times in ten, and it says nothing of clocks that differ by minutes, as the synthetic flights’ do.

To see the flight rather than read it, --ghost flight.czml writes the logs’ paths for a viewer, as ghost files explains.

--stages lays out one logger to a stage the same way, each leaving the pad with the stack, and gives no spread, a booster’s apogee and a sustainer’s being different heights. It has been checked only on simulated two-stage flights (evidence row G36).

What it doesn’t do yet

  • Read a format no sample holds yet, such as a CATS flight computer’s (the evidence row on such formats). The formats that need samples are listed, each with what a reader would need. A sample can be offered in #662.
  • Find the deployments as events: the main’s opening is read from the descent’s rate, not from the log’s record of when each charge fired.
  • Give the Mach number and dynamic pressure.
  • Take the top acceleration from a board’s three axes, which don’t say which lies along the rocket (#781). It comes only from an accelerometer the log names as the rocket’s axis (the accelerometer).
  • Allow for a canopy’s filling time in the main opening’s bound (#779).
  • Tell a fall under no canopy from one under a canopy: it’s read as one canopy’s descent (#780).
  • Take a reading from a GPS track: a receiver’s altitude lags the climb, so no bound can be stated for it.
  • Put a GPS track on a timeline with an altimeter’s log, or take a log read by a mapping into a pair, or read a pair from Python (#1086, #1085).
  • Compare a flight with its simulation: hpr compare does that (Comparing a flight with its simulation).
  • Check the heights near the speed of sound. It withholds the top speed from 227.7 m/s (747 ft/s), Mach 0.8 in the coldest air the bounds allow (the top speed). It doesn’t withhold the heights read there.
  • Hold its bounds beyond what they were checked on: six simulated logger profiles (the loggers) and rockets leaving the pad at 2 g or more. A noisier logger or a slower rocket can be read outside its bound.
  • Tell a charge’s spike from the top when the spike climbs into the top no faster than a coast can. Such a spike is read as the apogee, however high it stands (#761).
  • Give the top speed when the height drops at ignition, then climbs (disturbed_pad).
  • Tell every disturbed top from the rocket’s own. Some tops withheld as disturbed_top are the rocket’s own (#762).
  • Correct a barometric altitude for the day’s air. The altitude is the altimeter’s own conversion, which assumes a standard atmosphere (Barometric altimeter). The bound allows for air up to 15 K from standard instead. Past that, it notes the day but doesn’t widen the bound (A hot or cold day). It can only where the log records the pad’s temperature and its height above sea level: from its pressure, an altitude above sea level, or a stated ground elevation.
FusionSpace HPRVersion 0.1.0Issued 2026-11-21In preparationAbout HPR Sim