Launch Azimuth: Or, How to Tilt Your Orbit, If You're So Inclined

[Samniss Arandeen]

Introduction

Most of us are familiar with the simple "due east launch": just gravity turn 90 degrees and get into an orbit. To most of us, orbital inclination is merely a consequence of, say, a Minmus or Mun encounter, rather than anything we try to pursue actively. But what if we want to achieve a specific orbit? Plane-change dV is notoriously inefficient, and eats through a ship's fuel faster than you can say "stranded in space". Or, say you've landed and wish to take off again, or you're playing with Kerbin-Side and launching from an alternate spaceport. This will also apply to everyone who plays with RSS and has KSC set to the actual Kennedy Space Center launch site (22.5 degrees northerly latitude).

For the below tutorial, you will need:

-Your launch site's latitude. Positive values are northerly, negative values are southerly. Zero latitude is directly on the Equator.
-Your target semi-major axis. For a circular orbit, it's the planet's radius plus whatever altitude is needed/wanted.
-The planet's gravitational parameter in m^3/s^2, sidereal rotation period in seconds, and equatorial radius in meters.
-The target orbit's inclination. Note that inclination can never be lower than the launch site's latitude without the help of a correction burn later on.

Launch Azimuth

Put simply, the Launch Azimuth (β) is the heading along which a space launch is sent. Not only does this affect the inclination of the final orbit, but it affects the amount of dV used to place the vessel into orbit.

A handy formula to remember is: cos(i) = cos(φ) * sin(β), where i is the inclination, β is the launch azimuth, and φ is the launch latitude. Thank you, spherical trigonometry!

Let's say we want to launch from the KSC pad (at 0 degrees, 6 minutes, 9 seconds southerly latitude), heading into a 45 degree orbit to rendezvous with our space station.

We just solve our equation for β:

β = arcsin(cos(i)/cos(φ))

And plug in our values:

β = arcsin(cos(45)/cos(-.1025))
     = arcsin(.707/.999)

β = 45.000... degrees.

Great, so we have our launch azimuth, and we can space now, right?

Actually, no. While our equation is indispensable, it will only work in an inertial reference frame. Kerbin's surface is always rotating, and that velocity is transferred to our spacecraft. That velocity must be accounted for if we are to get a correct orbital inclination from the launch.

Accounting for Rotation

To transition from the rotating (initial) to the inertial (final) references, we need a way to account for the velocity already possessed by our launch vehicle prior to liftoff.

But how much velocity do we already have by rotation, do you ask? It's rather simple. Kerbin has a radius of 600,000 meters. Its rotation takes exactly one day, and because we know the circumference of a circle based on its radius (it's 2*π*r) and the time taken to cover that circumference (one day), we can get rotational speed.

Be careful, however. We can't use a solar day for this calculation. A solar day is calculated with respect to Kerbol; while this is fine for terrestrial timekeeπng and tracking the Sun's position, the rotation of Kerbin in a solar day is actually significantly more than one full revolution, as a solar day uses more rotation in order to keep the Sun in the same position at the same time of day. What we instead need is a measure of time called the "Sidereal Day" - the time it takes for exactly one full rotation of Kerbin without respect to Kerbol.

Looking around on the KSP Wiki, we see that Kerbin Sidereal Day = 21549.425 seconds, or 5 hours, 59 minutes, 9.425 seconds if you will.

We know that the circumference of Kerbin's Equator is (2*π*600000m), approx. 3769911.184 meters.

And with a rotation distance and time, we can get rotation speed. 3769911.184 meters/21549.425 seconds = 174.9425 meters/second velocity on Kerbin's equator. (Note: This value is also listed on Kerbin's entry on the KSP Wiki. I just wanted to show how it's calculated.)

But this value is on the equator, where the radius from the axis of rotation is equal to the radius of the planet. At increasing latitude, the radius from surface to axis progressively decreases, until finally at 90 degrees latitude, you're standing on the Pole itself and simply rotating coaxially with the planet. Luckily for us, the answer to this problem can be found by cutting Kerbin in half. That's right, by modeling our position on Kerbin as a right triangle, with the hypotaneuse represented by the radius from our launch site to Kerbin's center, we can simply take the cosine of our latitude to determine how much shorter our actual radius is - and just multiply that by our equatorial velocity. It really is that simple!

VRot(φ) = ((2*π*600000m)/21549.425s)*cos(φ)

VRot(-.1025) = ((2*π*600000m)/21549.425s)*cos(-.1025)
VRot(-.1025) = approx. 174.9422 m/s.

Not a whole lot different in our example, but consider that if you're launching from higher latitudes, it's an important consideration.

Alright, enough waffling about. We want to launch into a 45 degree orbit in an inertial reference plane. Our rotating planet moves us along due east at 174.9422 meters per second relative to the inertial frame. So how do we reconcile these into a number we can use? The answer is to use vector addition. If you think about it, our launch consists of a magnitude (delta V) and a direction (our azimuth). Our rotation is a magnitude (Vrot) and a direction (due east). If we add these vectors together, what we get is the final orbit magnitude (orbital velocity) and direction (inclination).

In an equation: Vlaunch + Vrot = Vdest.

Since we're solving for launch azimuth: Vlaunch = Vdest - Vrot.

But what is our orbital velocity? This is where we need to know exactly what orbit above Kerbin we want. This is important, as orbital velocity is affected by semi-major axis and altitude above Kerbin, and will differ depending on different orbits and mission goals. For our example, we want the 45 degree orbit to rendezvous with a space station in circular orbit 150 kilometers up.

(For the purposes of this tutorial, hopefully you already know how to calculate orbital velocities given semi-major axis and radius. If not, I'm just going to skim over my example briefly)

Since this is a circular orbit we're going to, we can simply take our semi-major axis of 750 kilometers and treat that as our radius to simplify things. Remember that our SMA is 750 km, not 150, as the focus of our orbit is at the center of Kerbin. The velocity of a circular orbit is Vcirc = (GM/R)^(1/2), where GM is the planet's gravitational parameter and R is our previously calculated radius.

Since we know Kerbin's GM = 3.5316*10^12 m^3/s^2, and our desired R is 750,000 m, we can calculate the velocity of destination orbit Vdest:

Vdest = (3.5316*10^12/750000)^(1/2)
Vdest = 2169.976 m/s.

A quick recap on what we know:

Vrot = 174.9422 m/s @ 90 degrees.
Vdest = 2169.976 m/s @ 45 degrees (our inertial launch azimuth)
Vlaunch = our horizontal delta-V requirement @ our rotational (compass) launch azimuth.

Vlaunch = Vdest - Vrot.

Let's add these vectors, shall we? First, we split them into their X (east/west) and Y (north/south) components.

Obtaining the X component of a vector is as simple as multiplying its magnitude by the sine of its direction. Therefore:

Vrotx = 174.9422 m/s * sin(90) = 174.9422 m/s
Vdestx = 2169.976 m/s * sin(45) = 1534.407 m/s

Vlaunchx = Vdestx - Vrotx
Vlaunchx = 1534.407 - 174.9422 = 1359.465 m/s

And for the Y component of a vector, the magnitude by the cosine of its direction. Thus:

Vroty = 174.9422 m/s * cos(90) = 0 m/s
Vdesty = 2169.976 m/s * cos(45) = 1534.402

Vlaunchy = Vdesty - Vroty
Vlaunchy = 1534.402 - 0 = 1534.402 m/s

We finally have X and Y components of our rotational launch vector. By combining them, we can finally see how much horizontal dV we need and what way to point it! It is at this point where I finally get to call in my good friend Pythagoreas. Since our X and Y velocities are perpendicular, we can treat them as sides of a right triangle.

Vlaunch = (Vlaunchx^2 + Vlaunchy^2)^(1/2)
Vlaunch = 2050.009 m/s

And the launch azimuth, the heading from North we need to launch?

tan(β) = Vlaunchx/Vlaunchy
β = arctan(Vlaunchx/Vlaunchy)
β = arctan(1359.465/1534.402)

β = 41.540 degrees.

 

Mathematician's Note: What may seem like mathematical incongruities result from more than a few rounding errors. I use Excel to get my numbers, and it goes to several times more decimal places each operation than I care to write down for the purposes of this tutorial; to someone plugging my given numbers into their calculators, my truncated decimals will most certainly propagate error all the way down. Most notably, the reason sin(45) and cos(45) are unequal is due to such a truncation thanks to the -.1025 degree latitude of the launch site in the calculation.

Spreadsheet: I placed a copy of the aforementioned spreadsheet in my Dropbox, downloadable HERE. The fields for gravitational and orbital parameters have been placed on their own sheet to be edited, so you can use it as a calculation aid.

[Cunjo Carl]

That title, oh what a title! And thanks for the guide- it was nice reading through to see how it works.

Edit: Also, I just noticed your icon is the truckers' stick shift. At first it didn't look weird because it's what I learned on. Now I have to know, why'd you pick it?

Edited September 12, 2016 by Cunjo Carl

[Aristarchus]

I have been dabbling in kOS and just finished a program designed to launch a vessel to match the inclination of a target in orbit. I wanted to test the impact accounting for the rotational velocity at launch could have, so I created a small experiment. I launched three identical vessels into low Kerbin orbit using the exact same flight path, controlled by my script. The target vessel was launched with a heading of 45 degrees and resulted in a final inclination of 40.1 degrees. The next two were launched exactly as the launch pad passed under the ascending node of the target vessel. The first was launched to naively match that inclination and ascended with a heading of around 50 degrees (90-40). The final inclination was 35.6 degrees. The last vessel incorporated the method in this tutorial (which I very much appreciated). Like the target vessel, it settled on a heading of almost exactly 45 degrees on ascent, though the final inclination was about 38.6 degrees. So while the result wasn't perfect, it did cut the error by more than half. The visual distinction is quite stark.

I was disappointed not to match the orbits exactly but I suspect the difference is due to an underpowered rocket that delivered far from instantaneous impulses. The orbital insertion burn took about a minute, mostly using the "Spark" engine. But I suppose that means that if you are launching into a specific inclination to save dV, the difference between properly calculating the heading and not is as important as properly designing the vehicle in the first place.

Anyway, this is just my long-winded attempt to say thanks for the tutorial!

Spoiler

The blue orbit is the target vessel. Yellow shows the adjusted ascent heading. White represents the nominal inclination heading.

Edited December 8, 2016 by Aristarchus

[sebseb7]

Vdest = 2169.976 m/s.

Would it be better when one uses the velocity at the point you enter vaccum?

this works for me:

set incl to 10.
lock angle1 to arcsin(max(-1,min(1,cos(180+incl)/cos(ship:latitude)))).
lock vlaunchx to (1600 * sin(angle1*-1))-(174.9422*sin(90)).
lock vlaunchy to (1600 * cos(angle1*-1))-(174.9422*cos(90)).
lock newangle to 90-arctan(vlaunchx/vlaunchy).
lock steering to lookdirup( HEADING(arcsin(max(-1,min(1,cos(180+newangle)/max(0.001,cos(ship:latitude))))), 90-pitch ):vector, ship:facing:topvector).