Telemetry accelerations calculations: lateral + longitudinal

[leonardobocci]

Hi, I am looking at telemetry scores and computing accelerations (lateral, longitudinal) and I can't quite wrap my head around the calculation of accelerations.

For lateral loads, my numbers seem to be in the right ballpark:
Using all sessions from 2023 and 2024, I get 94th percentile of lateral load around 57 m/s^2 (just under 6G) which aligns decently with what some articles claim:
https://www.mercedesamgf1.com/news/g-force-and-formula-one-explained
https://f1chronicle.com/f1-g-force-how-many-gs-can-a-f1-car-pull/#G-Force-During-Acceleration
I will consider the values above this to be outliers, and just trim them to 58 before applying a digital filter for smoothing.

However, for longitudinal loads, I seem to be way off. Based on the docs I assume the telemetry to be in 1/10M for a value of 1 for X or Y. https://docs.fastf1.dev/core.html#telemetry X (float): X position [1/10 m].
The conversion from m to m/s is a simple division, and the conversion of difference in time is from microseconds to seconds. The problem is that this produces very low peak acceleration numbers (~17 m/s^2 or 1.7G for 99th percentile). The articles claim that I should be seeing peak numbers around 40m/s^2(~4G).

Am I overlooking something entirely, or are longitudinal positive acceleration peaks not sustained for long periods and thus bunching up in very small percentiles?
I have not yet analysed the negative ones to check braking decelerations. Will probably post more tomorrow on this one.

Code for reference on longitudinal calculations:

... pl.col("SessionTime").diff().alias("delta_time"),  ...
df = df.with_columns(
            [
                (pl.col("Speed") / 3.6).alias("delta_ms_speed"),
                (pl.col("delta_time") / 1e6).alias("delta_s_time"),
            ]
        )
        df = df.with_columns(
            (pl.col("delta_ms_speed") / pl.col("delta_s_time")).alias(
                "longitudinal_acceleration"
            )
        )
...
#positive longitudinal
df_pos_long = df.filter(pl.col('longitudinal_acceleration') > 0)
df_pos_long.select(pl.col('longitudinal_acceleration').quantile(0.99)).collect(streaming=True)

[theOehrly]

I'll assume that your calculation of speed is correct and that you are not just calculating componentwise acceleration in cartesian coordinates? Else, that might be one reason why you are seeing low numbers.
Apart from that, many people, including me, have struggled to find a good way to calculate acceleration accurately. Usually, the values are unreliable and inaccurate. See also #507, #518 among others

To define the problem domain a bit more clearly, you are dealing with data that has

• a very low sample rate
• a non-constant timebase
• disturbances in time, i. e. values may be slightly shifted in time
• disturbances in value, i. e. values may be slightly shifted in magnitude

I am not able to fully explain the source of the disturbances with high confidence. But they certainly do appear.

I'd say that it is not unlikely that the inaccuracies of the raw data are causing the specific problem that you are seeing.

[leonardobocci]

So, I indeed there was a bug in the calculation of changes in speed. I was using speed instead of delta_speed before the conversion to m/s from km/h. The fix is in bold in the code below.
However, actually, after the fix, the values are obviously much much smaller, now not even remotely in the right ballpark (which makes sense as the numerator is now much smaller than before).

I'm actually not sure what you mean by componentwise acceleration. What I'm doing is taking the differences in speed and time, then coverting them respectively to m/s and s. After that, I am dividing them, to obtain m/s^2 acceleration. Is this an overly simplified approach?
pl.col("SessionTime").diff().alias("delta_time"),
pl.col("Speed").diff().alias("delta_speed"),
...
df = df.with_columns(
[
(pl.col("delta_speed") / 3.6).alias("delta_ms_speed"),
(pl.col("delta_time") / 1e6).alias("delta_s_time"),
]
)
df = df.with_columns(
(pl.col("delta_ms_speed") / pl.col("delta_s_time")).alias(
"longitudinal_acceleration"
)
)