# 2-stage rocket - minimum mass necessary

1. Jun 25, 2012

### hafman

1. The problem statement, all variables and given/known data

I have to design a two-stage rocket to accelerate a payload of 100kg from rest to a final velocity of 6,000 m/s (no gravity to worry about) using the minimum amount of mass for the rocket stages.

Each stage of the rocket must obey the following restriction:
Whatever the mass of the rocket stage & its fuel tanks, there must be 10x as much fuel. So if rocket stage 1 was 10,000 kg, then there must be 100,000 kg worth of fuel for a total (initial) mass of 110,000 kg in the first stage. Ditto with stage 2.

The rocket has a constant thrust velocity of 1500 m/s

The difficulty is I have to find the 'minimum' initial total mass of both stages required to get the payload up to the required final velocity.

2. Relevant equations

I know that in general the final velocity of a rocket is:

v = v0 + u * ln(m0/m1), so a two stage rocket would give:

$$v2 = u * ln(\frac{m0*m2}{m1*mf})$$

Where:
v0 = initial velocity of the rocket, either 0.0 m/s, or whatever the final speed of the last stage was.

m0 = initial total mass of the rocket before it begins burning.
m1 = final mass of the rocket after burning the stage 1 fuel.
m2 = initial total mass of stage 2 (anything left of stage 1 was ejected)
mf = final mass of the rocket - that's the stage 2 parts minus the fuel, and the payload.

3. The attempt at a solution

I'll use the following:
m10 = initial mass of stage 1, including the fuel.
m20 = initial mass of stage 2, including fuel.
u = 1500 m/s, exhaust velocity.

$$vf = u * ln( \frac{(m10 + m20 + mp) * (m20 + mp)}{(1/11*m10 + m20 + mp)*(1/11*m20 + mp)} )$$

This big mess of ugly comes out from combining the two stages through the properties of logarithms. Stage 2 has an initial velocity which is the final velocity of stage 1.

I get the 1/11*m10 and m20 in the denominator from assuming that all of the fuel is burned, so 10/11 of the mass of that stage is gone based on the restrictions stated earlier.

So this quickly turns into an algebra nightmare and I have to somehow find the minimum value of:

$$m10 + m20$$ to get a final velocity of 6,000 m/s.

I have to admit I'm kind of lost, I've tried multiplying through all the terms hoping to cancel stuff out, but only wound up back where I started.

However I have solved it by writing a small java function to brute force through all possible values of m10 and m20, and I get the following answer after a few billion calculations:

(m10 + m20) = 41773.24 kg
m10 = 39828.264 kg
m20 = 1944.976 kg

That's "good enough" for me, and to be honest it'll probably be accepted for full credit when I turn it in with a copy of the source code.

However I'd still like to know the "correct" way to derive this. My guess is that I have to rework the equation in terms of the mass as a function of velocity and use some calculus from there. But I honestly could use a few hints.

Here's the code (java) for the function I wrote:

public static void rocket()
{
double payload = 100.0; // The payload the rocket needs to haul.
double v = 6000.0; // The target velocity this rocket needs to reach.
double u = 1500.0; // Thrust velocity.
double delta = 0.001; // The change in mass for m10 and/or m20 for a brute force loop.
double v2 = 0.0; // The calculated guess, to compare to v.

// The minimum mass of the rocket (m10 + m20) - starting at an unrealistically high level so that
// almost anything will be lower.
double minMass = 1000000000.0;
String minLine = ""; // Prints out a formatted line of all the data for the minimum values.

double m10Start = 39800.0;
double m10End = 40000.0;
double m20Start = 1940.0;
double m20End = 1945.0;

double m10 = m10Start;
double m20 = m20Start;

for(m10 = m10Start; m10 < m10End; m10 += delta)
{
for(m20 = m20Start; m20 < m20End; m20 += delta)
{
count++;
if(v2 >= 6000.0)
{
if((m10 + m20) < minMass)
{
minMass = m10 + m20;
minLine = m10 + " + " + m20 + " = " + (m10 + m20) + " --- velocity = " + v2;
}
}

}
}

System.out.println(minLine);
System.out.println("Permutations run: " + count);
}

Sorry that it doesn't look great, the tabs are lost in copy/paste and I don't know if you guys have a nice code formatter similar to latex for math.