5
$\begingroup$

Given certain simplifying assumptions, a "linear tangent" steering law is optimal for orbital insertion of a launch vehicle:

$$\tan \psi = a\cdot t + b$$

i.e. the tangent of the flight path angle changes linearly from the point at which insertion guidance starts until circular orbit is achieved. My question is then how to compute the correct values for $a$ and $b$.

Assuming that an open-loop pitch guidance program is used for the initial ascent, linear-tangent guidance will take over from a given velocity vector and position, and our goal is to reach a given altitude with the correct horizontal velocity for circular orbit:

Is there a more direct way to determine the $a$ and $b$ coefficients than by a trial-and-error search algorithm? My application is for a generalized launch-to-LEO simulation tool.

$\endgroup$
4
$\begingroup$

The whole mathematical apparatus describing the rocket flight — gravity, rocket equation — it's a set of functions that take some parameters allowing you to model the process. If we set the thrust vector constant, we end with a complete equation of motion where we just plug parameters (Earth standard gravity, vehicle mass, $I_{SP}$ etc.) and we can numerically integrate it into the future. But if we want thrust to change direction, we must describe how it changes: parametrize it. We must have a function that models this change using some constants, so that we can integrate the trajectory using given constants OR retrieve them given the a trajectory. LTG (linear tangent steering law) is such a function — it only allows you to model control over the vehicle.

In order to retrieve the guidance constants you need a guidance algorithm, such as Powered Explicit Guidance. The Orbiter wiki describes PEG in a tutorial way so that you can try to implement it yourself. I found it quite hard to understand at first, so I'll also point you towards the original paper — with those two sources together you should be able to put it together. There are several others, such as Apollo's IGM (Iterative Guidance Mode) or Space Shuttle's UPFG (Unified Powered Flight Guidance), but the first does not have any easily available documentation and the other is just very complex.

Feel free to check out my own implementation on GitHub.

$\endgroup$
  • $\begingroup$ This doesn't match my understanding; doesn't an algorithm like PEG completely supersede linear tangent guidance? $\endgroup$ – Russell Borogove Dec 12 '16 at 1:50
  • 1
    $\begingroup$ No, PEG incorporates LTG as a model of control over the vehicle just as inverse-square law is a model of gravity and the ideal rocket equation models vehicle dynamics. LTG gives you free variables in the equation, without it you simply have nothing to handle the process with. That's about as good an explanation as I can give - I strongly suggest reading the original paper for a more thorough one. $\endgroup$ – Przemek D Dec 12 '16 at 10:06
  • $\begingroup$ @RussellBorogove the a and b values you're looking for are just the lambda and lambda-dot values that PEG computes. $\endgroup$ – lamont Oct 29 '17 at 6:53
  • $\begingroup$ @Przemek D, would it be possible to contact you privately? I was intrigued by your PEGAS guidance algorithm... I'm in need of something similar, but implemented in C++, since I have zero experience in kOS. Any chance to translate it into C++, or at the very least, pseudocode? $\endgroup$ – Mitch99 Mar 30 at 6:30
  • $\begingroup$ @Mitch99 This would be best discussed on my github - if you want to contact me, I suggest opening an issue and providing me with your email so I can text you back. $\endgroup$ – Przemek D Mar 31 at 14:38

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.