The SRBs for the Shuttle are fairly unpopular devices, and I had been wondering if the Shuttle might have been able to use gas turbines as a booster in their place. Preceeding work identified that of three engine choices the most likely was the Olympus fitted with a military afterburner system. Obviously any equivalent modern jet engine with the same sort of performance could be substituted.
The flight path has to be modified to take into account the performance limitations of a gas turbine. I set limits
of Mach 3 and 20 km altitude for a gas turbine. The main engine has to be enlarged as well, as there is too much
left to do to get the 99 tons of Shuttle into LEO from 20km/M3.
Rather than hand-optimising this setup I used a Genetic Algorithm to search for a near optimum solution. This takes
about 2.5 minutes per generation, each of which consists of 79 individuals. The results are heavily dependent on
the scoring system used, in a study like this there is a lot of guesswork. Real projects can use cost or some other
objective performance parameter. I penalised the number of main engines and jet engines, and rewarded it for high
orbital velocity. There's a very heavy penalty for failing to reach 170 km altitude or 7.8 km/s. That's the reason
for the big jumps early on. Here's the run, the top line is the score of the best solution in that generation,
the jagged line beneath is the average of the entire population. The neat thing with GA is that even if you make
all sorts of stupid mistakes in the code, so long as you leave the best so far in the population, and the score
of the best keeps going up, then it is working, to at least some extent! If a different scoring function is used
then a different setup would win, but this one is pretty typical. Note that the GA is being used to set values
for variables that are not explicitly used in the scoring function. More sophisticated GA solvers use some ways
of keeping associated genes together.
As can be seen there wasn't much point in running past 80 generations.
Here's the simulator results for the best solution. The odd pattern on the Angle plot is the autopilot correcting
for excessive upward speed by pitching down - this model just uses a speed vs height feedback loop, the parameters
for which are part of the optimisation. Incidentally this sim is ballistic, so it doesn't really understand orbits,
and so has a correction factor for non-existent centrifugal force.
The blue line in the speed plot is the vertical speed.
As can be seen the takeoff weight is around 1050 tonnes, substantially (and suspiciously) better than the real
thing, at 2030 tonnes, but just about believable given that the SRBs weigh 1180 tonnes, and that this simulator
probably overloads the aerodynamics of the rocket, since the real thing uses a lot of logic to reduce aerodynamic
loads, including throttling the main engine back to 60% throttle at one point. The jet engines would weigh around
100 tonnes, and would need 20 tonnes of fuel or so.
Here are the parameters. That is, it needs 32 Olympus engines, which burn for 102 seconds. These would probably
fit quite neatly around the main fuel tank, which is 9m in diameter. The main engine needs to be 1.4142 (coincidence)
times bigger than the real thing, and needs to carry 16% more fuel than the real thing.
burntime1 = 102.1716
num_engines1 = 32.042547
mult = 1.414206
ftmult = 0.8229295
These are the autopilot settings.
VH = 0.1780584
VL = 0.7062749
srbrate = 0.7645187
srbcap = 28.737744
And here's the results
score 0.4323032
V(599) 7879.1759 m/s
Here's the scoring function
For the truly masochistic here is the autopilot function. Basically while the SRBs are present it just pitches over at a constant rate, until it reaches a limit, then it flies at that limit until the SRBs fall off. Then it uses the pitch to control the upward velocity of the Shuttle until it reaches orbit and the main engine burns out. The plot above shows that it spends a lot of time in Mode 4, which smoothed out the ride a lot. It is quite important to have a robust autopilot strategy, as the GA solver works best with a result from every run, not an error message!
vh=VH*10^6/180*(180-(H(t-1))/1000);
vl=VL*vh;
aveang=Angle(t-1)+30*aveang;
aveang=aveang/31;
Angle(t)=aveang;Mode(t)=4; //default option
// fly by dead reckoning for srb
srbcap=srbcap;
srbrate=srbrate;
vh=VH*10^6/180*(180-(H(t-1))/1000);
vl=VL*vh;
if srb==1 then
Angle(t)=Angle(t-1)+srbrate/360*2*%pi;Mode(t)=0;
if Angle(t)>srbcap/360*2*%pi then Angle(t)=srbcap/360*2*%pi; end;
end;
//start of main autopilot loop
pitch=10/360*2*%pi;
if srb==0 then
//too fast upwards
if (Vy(t))^2>vh then
Angle(t)=Angle(t-1)+pitch;
Mode(t)=3;
end;
//too slow upwards
if (Vy(t))^2<vl then
Angle(t)=Angle(t-1)-pitch;
Mode(t)=5;
end;
//falling down
if Vy(t)<0 then
if Y(t)<(r+180000) then
Angle(t)=Angle(t-1)-pitch;
Mode(t)=6;
end;
end;
end;
//end of main autopilot loop
if Thrust(t)==0 then
Angle(t)=%pi/2;
Mode(t)=7;
end;
// if it falls below ground level point it up
if Y(t)<r then Angle(t)=0;Mode(t)=8;end;
// tidy up angle
if Angle(t)<0 then Angle(t)=0; end;
if Angle(t)>(.6*%pi) then Angle(t)=(.6*%pi); end;