Fraser, @MM0EFI, has been chipping away at his Cairngorms National Park summits, and was down to his final three, one of which was Carn Dearg, GM/CS-037. As one of the Monadh Liath Munros, it is often walked with another two, Càrn Sgulain and A’ Chailleach - neither of which are SOTA summits. Surprisingly, (although maybe less so after the fact) Fraser had never made it up these munros before, and so it would be a new route and summits for both of us.
Despite owning six vehicles, Mo had to drop him off at the nearest public toilets for me to collect along the way. It was a pleasant morning and very mild. It had rained considerably the past few days and Fraser had advised me to bring gaitors. This appeared to be one of those “do as I say, not as I do” as he showed up naked (gaitorly speaking). We decided to do the two non-SOTA summits first, and set off up the river towards A’Chailleach.
The river crossing wasn’t striaght forward, but we made it without incident, again, remembering our dear friend Chris @2M0RVZ, only to find that this might’ve been the driest part of the route. Like most days out, I try to estimate the schedule, as I often have to be home for some family thing. Today, I was meant to be home by 5pm to make kids dinner before the school show drop off at 5:30 (Back to the 80s High School Musical - for all the parents in the audience 
). I reckoned we were fine and I’d be home in plenty of time, even with all the sweetie stops and sit downs we have to do.
After about an hour and a half we reach the first summit. The weather was ever changing and low cloud loomed to one side and blue skies to the other, but it was dry and we had decent views, including our final summit waaay in the distance. 45 minutes of unremarkable walking had munro #2 ticked off. It would’ve been 44, but Fraser wanted to go to the second cairn.
We then began the 8 km walk across the plateau to our final summit, and actual radio activation. The ground was somewhat drier now, although the periodic bogs helped maintain the route’s average water content. I managed to go gaitor deep into one bog, and whilst I swam across to the other side, I’d left Fraser stranded in the middle. Probing the ground with his pole sent him back to the other side looking for a new path across. It was now very apparent my forecasting model doesn’t work so well for long flat walks, and there was as much float as my bog walk.
As we finally approach the summit, we get a better look at the impressive sight of Carn Dearg. After two nondescript munros, this one stands out with its dramatic peak and views into the Gleann below.
@MW0CBC was out on Carn Glas-choire, GM/CS-091, just up the road and was setting up on top. We easily managed a S2S with Denis - giving both him and Fraser completes. Carn Dearg is a very exposed summit, and the wind was continous and strong. We called CQ and Gordon in Mallaig was soon in the log. Another CQ and this time Archie, @GM4KNU, popped up on Carn na Caim, GM/CS-039, just across the road. Three down and one to go! Given the time it had taken to get here, I was hoping for a quick activation on 2m. Alas! It was not to be. Fraser kept calling on 2m whilst I setup on HF. With the cairn right on the edge, and the SW wind, I was tempting fate for the mast and antenna to be blown over the cliff.
With the summit qualified, and a long walk back to the car, we packed up and headed on. Fraser was tempted by a shortcut over the edge, but decided against it on the basis that one of us dying wouldn’t help with timing. It was a long squelch down the hill, towards and round Creag Laith before we reached a firm path.
After looking forward to a nice path for 22 km, it turns out that our firm soled Altbergs offered little cushioning for the hard track back to the car, and maybe that ankle deep sodden moss wasn’t so bad after all. I was much more prepared this time, with branded sweets, iced mince pies and Irn Bru - although I think they spoiled someone’s dinner. It was time for a prompt drive home, pushing Fraser out the car as we passed the public loos, to get home in time for the school show.
Dinner instructions were texted ahead and we reached the school at 5:31…Phew!
Epilogue
I typically use plotaroute.com to plan route timings, and like many other similar websites it allows you to put in your walking/cycling speed and parameters to adjust for ascents and descents. Search the forum for Naismith’s rule and I’m sure it has been discussed ad nausum in excruiticating details. For the past year, my predictions with whatever parameters I had set, had worked well. I was typically close enough ±, but I’d just been lucky with my faster than predicted ascents averaging out with my slower than predicted flat walks. I’d probably arbrtarily fitted the parameters to one walk once upon a time and left it at that.
Arbitrary no more. Given I collect my outings on my Garmin, I have the answers right here. Download the gpx, LLM some code, and now I can history match the parameters to the walk. I picked three decent length walks to compare and there are variations - just like the walk and terrain itself.
There are some nice tools to get your data out of Garmin. e.g. this, that, the other. So the obessiveness in me can compute the parameters for all historical walks/cycles and generate a distribution curve of parameters to then perform a monte carlo simulation on how long it’ll take. Being able to offer Fraser P10, P90 and EV times.
For him to look at the map and go “…probably 1:45”.
Code if you care
#!/usr/bin/env python3
"""
hike_speed_analysis.py
Analyse a GPX track to estimate walking speed and hill adjustment factors
for Plotaroute.com:
- Flat speed (km/h)
- Equivalent flat distance for climbing/descending (x, y, z)
It also saves a CSV with all derived metrics for further analysis.
Usage:
python hike_speed_analysis.py my_hike.gpx
"""
import sys
import pandas as pd
import numpy as np
from math import radians, sin, cos, sqrt, atan2
import gpxpy
import os
def haversine(lat1, lon1, lat2, lon2):
"""Return distance in metres between two lat/lon points."""
R = 6371000
dlat = radians(lat2 - lat1)
dlon = radians(lon2 - lon1)
a = sin(dlat/2)**2 + cos(radians(lat1))*cos(radians(lat2))*sin(dlon/2)**2
return 2 * R * atan2(sqrt(a), sqrt(1-a))
def classify_slope(slope):
"""Classify gradient into terrain categories."""
if slope > 0.05:
return "uphill"
elif slope < -0.12:
return "steep_down"
elif slope < -0.01:
return "gentle_down"
else:
return "flat"
def analyse_gpx(gpx_file):
# Parse GPX
with open(gpx_file, "r", encoding="utf-8") as f:
gpx = gpxpy.parse(f)
data = []
for track in gpx.tracks:
for segment in track.segments:
for point in segment.points:
data.append((point.latitude, point.longitude, point.elevation, point.time))
if not data:
print("No track points found in GPX.")
sys.exit(1)
df = pd.DataFrame(data, columns=["lat", "lon", "ele", "time"])
df = df.sort_values("time").reset_index(drop=True)
# Distances (m)
distances = [0]
for i in range(1, len(df)):
distances.append(haversine(df.lat[i-1], df.lon[i-1], df.lat[i], df.lon[i]))
df["delta_dist"] = distances
df["distance_m"] = np.cumsum(distances)
# Elevation and slope
df["delta_alt"] = df["ele"].diff().fillna(0)
df["slope"] = df["delta_alt"] / df["delta_dist"].replace(0, np.nan)
# Time and speed
df["delta_t"] = df["time"].diff().dt.total_seconds().fillna(0)
df = df[df["delta_t"] > 0]
df["speed_kph"] = df["delta_dist"] / df["delta_t"] * 3.6
# Clean noisy data
df = df[(df["speed_kph"] > 0.1) & (df["speed_kph"] < 10) & (df["delta_dist"] > 0.3)]
# Classify terrain
df["terrain"] = df["slope"].apply(classify_slope)
# Compute mean speeds
mean_speeds = df.groupby("terrain")["speed_kph"].mean()
flat_speed = mean_speeds.get("flat", np.nan)
# Equivalent flat ratios
def eq_ratio(t):
return flat_speed / mean_speeds[t] if t in mean_speeds and flat_speed else np.nan
ratios = {t: eq_ratio(t) for t in ["uphill", "gentle_down", "steep_down"]}
# Print summary
print("\n--- Hike Speed Analysis ---")
print(f"Flat speed: {flat_speed:.2f} km/h")
for t, r in ratios.items():
label = {
"uphill": "Climb (x)",
"gentle_down": "Gentle descent (y)",
"steep_down": "Steep descent (z)"
}[t]
if pd.notna(r):
print(f"{label}: equivalent {r:.2f} m per 1 m elevation")
print("----------------------------")
# Save CSV
out_path = os.path.splitext(gpx_file)[0] + "_analysis.csv"
df.to_csv(out_path, index=False)
print(f"Detailed data saved to: {out_path}")
if __name__ == "__main__":
if len(sys.argv) < 2:
print("Usage: python hike_speed_analysis.py <file.gpx>")
sys.exit(1)
analyse_gpx(sys.argv[1])
Then I’d naturally have to meddle and modify the result to add the bunce for the numerous pauses for photographic opportunities that are required.
