1. Not finding help here? Sign up for a free 30min tutor trial with Chegg Tutors
    Dismiss Notice
Dismiss Notice
Join Physics Forums Today!
The friendliest, high quality science and math community on the planet! Everyone who loves science is here!

2-stage rocket - minimum mass necessary

  1. Jun 25, 2012 #1
    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:

    [tex]v2 = u * ln(\frac{m0*m2}{m1*mf})[/tex]

    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.
    mp = mass of payload.
    u = 1500 m/s, exhaust velocity.

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

    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:

    [tex]m10 + m20[/tex] 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++;
    v2 = u * Math.log(((m10 + m20 + payload)*(m20 + payload)) / ((1.0/11.0*m10 + m20 + payload)*(1.0/11.0*m20 + payload)));
    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.
     
  2. jcsd
Know someone interested in this topic? Share this thread via Reddit, Google+, Twitter, or Facebook

Can you offer guidance or do you also need help?
Draft saved Draft deleted



Similar Discussions: 2-stage rocket - minimum mass necessary
  1. 2 Moving masses (Replies: 0)

Loading...