Telemetry & the loss budget

1 — Tick rate. 23 columns × 9 bytes ≈ 207 bytes/row. At 50 Hz for 220 s that's 11 000 rows, about 2.3 MB — per flight. Fly the six configurations this tutorial asks for and you have 14 MB of CSV to drag into a browser tab.

2 — Resolving max-Q. 40 samples across a 20-second feature is one every 0.5 s. Round down for margin: 0.25 s, or 4 Hz. That is comfortably enough to see the shape of every curve in this series, including the sharp ones.

3 — What you gave up. 220 s at 4 Hz is 880 rows, about 180 kB. You threw away 92% of the data and lost nothing you were going to look at. The tick-rate version bought you resolution finer than the thing you're measuring — and it cost you a file the analyser has to chew through, plus a disk write every 20 ms in the middle of a flight.

4 — And here is the split that matters. Nearly nothing. The integrand g sin γ is smooth and slow — γ swings 90° over two minutes — so a 0.25 s rectangle rule tracks it to well under a m/s across the whole ascent.

But that is a statement about this integrand. Thrust is not smooth: staging drops it to zero and back in a single tick. Sample the ideal-Δv integral at 4 Hz and a stage separation that happens between two samples gets integrated as though the engine never cut out.

So the answer isn't one rate. It's two:

The accumulators are cheap — a few multiplies — and they need every tick to stay honest. The file write is expensive and needs 4 Hz. Splitting them is the single most important structural decision in launch4.ks.

1 — Along-track equation of motion. Thrust contributes F cos α (only its component along v). Drag acts directly backwards along v, so it's −D. Gravity points at the centre of the body; the angle between "straight down" and "backwards along v" is 90° − γ, so its along-track component is −mg sin γ.

Note that when γ = 0 — flying flat — gravity does nothing to your speed at all. It's still bending you, but it isn't slowing you. That single fact is the entire argument for the gravity turn.

2 — Divide and integrate.

3 — Pull the steering loss out. Write cos α as 1 − (1 − cos α):

The first integral is Δv_ideal. The second is the steering loss, and because cos α ≤ 1 always, it is never negative — you cannot gain speed by pointing away from where you're going. It's also quadratic in α for small angles: cos α ≈ 1 − α²/2, so 5° of misalignment costs you 0.4% of your thrust and 20° costs 6%. Small angles are genuinely cheap, which is why a slightly-off gravity turn is fine and a badly-off one is not.

4 — The bill.

L_grav = ∫g sin γ dt  ·  L_drag = ∫(D/m) dt  ·  L_steer = ∫(F/m)(1 − cos α) dt

Everything the tanks gave you is either speed you still have, or one of three named ways you threw it away. There is no fourth bucket and nothing is unaccounted for. That's what makes this worth measuring rather than estimating.

5 — The hover check. TWR = 1 means F/m = g. Pointing straight up and not moving, γ is 90° (you're going nowhere, but the instant you move it's straight up), α = 0, D = 0, and speed never changes.

• Δv_ideal = g × 30 = 294 m/s
• L_grav = g sin 90° × 30 = 294 m/s
• L_drag = L_steer = 0, and Δv_gained = 0

294 = 0 + 294 + 0 + 0. It balances, and it tells you something brutal: thirty seconds of hovering costs you 294 m/s and buys you nothing. Every second your rocket spends pointed straight up is being billed at g per second. That is the number Arc 3 spends four tutorials attacking.

1 — Orbital frame at liftoff. You're moving at 175 m/s horizontally (east, with the ground) and 0 m/s vertically. So γ = 0°. The rocket points straight up, so α = 90°, and the steering integrand is (F/m)(1 − cos 90°) = F/m — the entire thrust is booked as steering loss, and the gravity loss is g sin 0° = 0.

That is not a bug. It's the honest inertial answer: you are already orbiting slowly, and pointing straight up is 90° away from where that motion is going. But it means your budget reports a vertical launch as a steering problem and not a gravity problem, which is going to be a very hard sell in Arc 3.

2 — Surface frame at liftoff. γ = 90° once you're moving, α = 0, gravity loss runs at the full g. Exactly the intuition, and exactly the hover check from the last section.

The problem: at t = 0 the surface speed is 0, so γ = arcsin(0/0) and your script divides by zero on its first tick. Guard it — below about 1 m/s of surface speed, just declare γ = 90° and α = 0. You're on the pad; it's true.

3 — Formally. The orbital frame is the inertial one, so the derivation is exactly valid there and only approximately valid in the rotating surface frame. In the surface frame there are centrifugal and Coriolis terms that the derivation dropped.

4 — What to actually do. Log the budget in the surface frame, and write down why.

Two reasons. First, it matches every other ascent analysis you will ever read, so your numbers are comparable to other people's. Second, and more importantly for this series: the surface frame is the one where the losses are attributed to the thing you can change. Your pitch program is written in surface-relative terms; you want a budget that tells you what your pitch program cost you.

The price is that the frame terms you dropped don't vanish — they land in the residual, which is the drag bucket. At Kerbin's rotation rate they're small compared to drag through the lower atmosphere, but "small" is a claim, and in Tutorial 06 you'll build a drag model good enough to test it.

So the honest column header is not "drag loss". It's "drag loss and everything else I didn't model" — and the next section is about taking that seriously.

1 — Five seconds of phantom gravity loss. If lastTick is set at the top of the file and the countdown runs for five seconds, the first dt inside the loop is 5.0, not 0.02. The rocket was sitting on the pad the whole time, but your accumulator books g sin 90° × 5 ≈ 49 m/s of gravity loss before liftoff.

49 m/s is small enough to look plausible and large enough to change your conclusions. Set lastTick on the line immediately before the loop — after STAGE., not before the countdown.

2 — Zero dt is harmless; the guard is for something else. A pass with dt = 0 adds exactly zero to a rectangle rule, so it costs nothing but a wasted evaluation. The IF dt > 0 guard exists for a different reason: if you're computing anything by dividing by dt — a numerical derivative, say — that pass is a division by zero.

The trapezoid rule is a different story. It averages the current integrand with the previous one, which means it has to store the previous one. A zero-length step overwrites your stored value with an identical one — harmless — but it does mean the trapezoid's error advantage over the rectangle rule evaporates when your step sizes are erratic. At 50 Hz over a smooth integrand, neither is worth arguing about. Use the rectangle rule and spend the attention elsewhere.

3 — Yes, and mostly. TIME:SECONDS is game time, so it advances at 0.08 s per tick under 4× physics warp and your dt is automatically right. The integral stays unbiased.

What degrades is resolution: you get a quarter as many samples across the same manoeuvre. Through staging events and max-Q that matters. The practical rule for this series is don't physics-warp a logged ascent — and since you'll want to compare runs, warping some and not others is worse than warping none.

On-rails time warp is a different beast entirely: physics is off, your loop barely runs, and thrust is impossible. That's not a logging problem, it's a "you can't do that" problem, and kOS will refuse to warp on rails while the throttle is up.

• Rotating-frame terms. The centrifugal and Coriolis contributions you dropped when you chose the surface frame. Small at Kerbin's rotation rate, but not zero, and they grow as you build horizontal speed.
• Thrust misreporting. If you accumulate SHIP:AVAILABLETHRUST instead of actual thrust, then every second at part throttle inflates Δv_ideal, and the whole inflation lands in drag. This is the big one, and it's why the schema logs actual thrust.
• The α convention. VANG(SHIP:FACING:VECTOR, …) is where the nose points, which is not where the engines push if you have gimballed engines mid-correction, or a control-surface trim. Usually within a degree; occasionally not.
• Integration error at staging. Thrust steps discontinuously. Any tick where the accumulator's thrust reading and the actual thrust disagree gets billed to drag.
• Engine spool time. Real engines take a moment to reach full thrust; if you read thrust at the top of the tick and it changes during the tick, the difference accumulates.
• Vertical speed vs. radial speed. SHIP:VERTICALSPEED is the rate of change of altitude, which is radial. Over a curved surface at high horizontal speed, "up" is rotating underneath you. Tiny, but it's in there.

So how do you know if your drag number is any good? Two checks, both cheap:

1. The vacuum test. Fly the same script on the Mun, or above 70 km on Kerbin. True aerodynamic drag is exactly zero there. Whatever your residual reports is pure error, and now you know its size.
2. The shape test. Plot lossDrag against altitude. Real drag loss accumulates almost entirely between about 5 and 20 km and then flattens completely. If your curve keeps climbing above 40 km, you are not looking at drag.

Do the vacuum test before you trust a single drag number in Arc 3. It takes one flight and it calibrates every measurement you make afterwards.

// launch4.ks — launch3 plus instrumentation.
// Flies identically. Ends with an itemised delta-v bill.

CLEARSCREEN.

// ---- constants ----
SET g0 TO 9.80665.

// ---- run identity ----
SET runTag TO "k05_h1000".
SET logFile TO "0:/run_" + runTag + ".csv".

// ---- ascent target ----
SET targetAp TO 75000.
SET azimuth  TO 90.

// ---- ascent profile ----
SET turnStart TO 1000.
SET turnEnd   TO 45000.
SET pitch0    TO 90.
SET pitch1    TO 0.
SET shapeK    TO 0.5.

// ---- staging ----
SET cooldown     TO 1.
SET lastCooldown TO TIME:SECONDS.

// ---- instrumentation state ----
SET sampleDt   TO 0.25.
SET nextSample TO 0.
SET lastTick   TO 0.
SET t0         TO 0.
SET dvIdeal    TO 0.
SET lossGrav   TO 0.
SET lossSteer  TO 0.
SET telemetryRow TO 0.

// ---- open the log ----
IF EXISTS(logFile) { DELETEPATH(logFile). }
LOG "run,k,h0,h1,ut,met,alt,vsrf,vorb,vspd,gamma,pitch,alpha," +
    "mass,thrust,dynp,ap,pe,dvIdeal,lossGrav,lossSteer,lossDrag,stagenum" TO logFile.

// ---- countdown ----
FROM {LOCAL c IS 5.} UNTIL c = 0 STEP {SET c TO c-1.} DO {
  PRINT "T-MINUS          " + c AT (0,0).
  WAIT 1.
}

SAS OFF. RCS OFF.
LOCK THROTTLE TO 1.
LOCK STEERING TO HEADING(azimuth, pitchAt(SHIP:ALTITUDE)).
STAGE.
PRINT "LIFTOFF             " AT (0,0).

// Start the clocks HERE — not at the top of the file, or the
// countdown's five seconds get integrated as gravity loss.
SET t0         TO TIME:SECONDS.
SET lastTick   TO TIME:SECONDS.
SET nextSample TO TIME:SECONDS.

// ---- ascent loop ----
UNTIL SHIP:APOAPSIS > targetAp {
  accumulate().            // every tick — the integrals need it
  IF TIME:SECONDS >= nextSample {
    logRow().
    SET nextSample TO nextSample + sampleDt.
    // If we fell behind (lag, a long tick), don't spend the next
    // N passes catching up at tick rate — resync to now.
    IF nextSample < TIME:SECONDS { SET nextSample TO TIME:SECONDS + sampleDt. }
  }
  printTelemetry().
  autoStage().
  WAIT 0.
}

// ---- MECO ----
LOCK THROTTLE TO 0.
accumulate().
logRow().
PRINT "MECO                          " AT (0,0).
WAIT 1.
UNLOCK STEERING. UNLOCK THROTTLE.
printBudget().

// ================= instrumentation =================

FUNCTION gNow {
  LOCAL r IS SHIP:BODY:RADIUS + SHIP:ALTITUDE.
  RETURN SHIP:BODY:MU / (r * r).
}

// Flight path angle above the horizon, surface frame, in degrees.
// On the pad vsrf is 0 and the ratio is undefined — we're pointed
// up and going nowhere, so 90 is the honest answer.
FUNCTION gammaNow {
  LOCAL sp IS SHIP:VELOCITY:SURFACE:MAG.
  IF sp < 1 { RETURN 90. }
  RETURN ARCSIN(MIN(MAX(SHIP:VERTICALSPEED / sp, -1), 1)).
}

// Angle between where we point and where we're going, in degrees.
FUNCTION alphaNow {
  IF SHIP:VELOCITY:SURFACE:MAG < 1 { RETURN 0. }
  RETURN VANG(SHIP:FACING:VECTOR, SHIP:VELOCITY:SURFACE).
}

// ACTUAL thrust, not available thrust. The difference is
// throttle setting and atmospheric derating, and it goes
// straight into dvIdeal if you get it wrong.
FUNCTION actualThrust {
  LOCAL total IS 0.
  LIST ENGINES IN es.
  FOR e IN es {
    IF e:IGNITION AND NOT e:FLAMEOUT {
      SET total TO total + e:THRUST.
    }
  }
  RETURN total.
}

// Called EVERY tick. Rectangle rule on three integrals.
FUNCTION accumulate {
  LOCAL now IS TIME:SECONDS.
  LOCAL dt  IS now - lastTick.
  SET lastTick TO now.
  IF dt <= 0 { RETURN. }

  // kN / t is m/s^2 exactly — no conversion.
  LOCAL aT IS actualThrust() / SHIP:MASS.

  SET dvIdeal   TO dvIdeal   + aT * dt.
  SET lossGrav  TO lossGrav  + gNow() * SIN(gammaNow()) * dt.
  SET lossSteer TO lossSteer + aT * (1 - COS(alphaNow())) * dt.
}

// Drag is the only term we can't measure, so it's the residual.
// Read the tutorial section on what else ends up in here.
FUNCTION lossDrag {
  RETURN dvIdeal - SHIP:VELOCITY:SURFACE:MAG - lossGrav - lossSteer.
}

FUNCTION logRow {
  LOG runTag
    + "," + shapeK
    + "," + turnStart
    + "," + turnEnd
    + "," + ROUND(TIME:SECONDS, 2)
    + "," + ROUND(TIME:SECONDS - t0, 2)
    + "," + ROUND(SHIP:ALTITUDE, 1)
    + "," + ROUND(SHIP:VELOCITY:SURFACE:MAG, 2)
    + "," + ROUND(SHIP:VELOCITY:ORBIT:MAG, 2)
    + "," + ROUND(SHIP:VERTICALSPEED, 2)
    + "," + ROUND(gammaNow(), 2)
    + "," + ROUND(pitchAt(SHIP:ALTITUDE), 2)
    + "," + ROUND(alphaNow(), 2)
    + "," + ROUND(SHIP:MASS, 3)
    + "," + ROUND(actualThrust(), 2)
    + "," + ROUND(SHIP:Q * 101.325, 3)   // atm -> kPa
    + "," + ROUND(SHIP:APOAPSIS, 1)
    + "," + ROUND(SHIP:PERIAPSIS, 1)
    + "," + ROUND(dvIdeal, 2)
    + "," + ROUND(lossGrav, 2)
    + "," + ROUND(lossSteer, 2)
    + "," + ROUND(lossDrag(), 2)
    + "," + STAGE:NUMBER
    TO logFile.
}

FUNCTION printBudget {
  LOCAL kept IS SHIP:VELOCITY:SURFACE:MAG.
  PRINT "---- delta-v bill ----------" AT (0,2).
  PRINT "ideal      " + ROUND(dvIdeal,1)   + "     " AT (0,3).
  PRINT "kept       " + ROUND(kept,1)      + "     " AT (0,4).
  PRINT "gravity    " + ROUND(lossGrav,1)  + "     " AT (0,5).
  PRINT "steering   " + ROUND(lossSteer,1) + "     " AT (0,6).
  PRINT "drag+resid " + ROUND(lossDrag(),1) + "     " AT (0,7).
  PRINT "apoapsis   " + ROUND(SHIP:APOAPSIS)  + "     " AT (0,8).
  PRINT "logged to  " + logFile AT (0,9).
}

// ================= from launch3 =================

FUNCTION turnFraction {
  DECLARE PARAMETER h.
  LOCAL f IS (h - turnStart) / (turnEnd - turnStart).
  RETURN MIN(MAX(f, 0), 1).
}

FUNCTION pitchAt {
  DECLARE PARAMETER h.
  RETURN pitch0 + (pitch1 - pitch0) * (turnFraction(h) ^ shapeK).
}

// ... allEnginesBurned(), shouldStage(), autoStage(),
// ... printTelemetry() — unchanged from launch3.ks

Why logRow is one enormous expression

Because LOG writes a line per call, and a line is one string. Building it with twenty-two + operators is ugly and it is also the only shape that doesn't cost you an extra file write per column. If it bothers you, build a LIST of values and join it — kOS has JOIN on lists — but be aware you're now allocating a list every quarter second for the rest of the flight.

On e:IGNITION AND NOT e:FLAMEOUT

Tutorial 03's currentThrust() filtered engines by e:stage = stage:number. That's the right question for "what will this stage do", and the wrong question for "what is pushing me right now" — an engine from a previous stage that's still lit doesn't match, and a not-yet-ignited engine in the current stage does. For the accumulator you want the engines actually burning. Two different questions, two different filters; keep both functions.

What you should have seen across the six runs

Lower k should give lower gravity loss and higher drag loss, with the total bottoming out somewhere around k ≈ 0.4–0.5 for a typical stock rocket. If your k = 0.4 run reached the same apoapsis with less total loss than k = 1, you have just measured the claim Tutorial 02 asked you to take on trust.

The turn-start sweep is the more interesting one. Turning at 250 m usually looks great in the gravity-loss column and terrible in the drag column, and on many rockets it also loses control authority low and slow — which shows up as a spike in the alpha column that the steering-loss integral then bills you for. Three columns, one story. That's the analyser earning its keep.

If your total losses come out under about 1000 m/s or over about 2500 m/s, be suspicious before you're pleased. Sanity-check dvIdeal at MECO against a hand-computed Tsiolkovsky from Tutorial 03 — they should agree within a few percent, and if they don't, your thrust filter is wrong.