Physics 3 - Fall Laboratory 6 - Orbits and Gravitation. 1) To demonstrate Kepler's three laws of planetary motion;

Transcription

1 Physics 3 - Fall 1988 Laboratory 6 - Orbits and Gravitation Many pheonomena we study in this course lend themselves nicely to laboratory excercises and demonstrations - physics is all around us! But gravitation is an exception. While we experience it every day, we are only aware of it as a steady 9.8 m/s 2 acceleration downward, leading to the familiar phenomena of projectile motion and so on. In the larger world - the universe - gravitation works with a much richer palette. The force of gravitation falls off with distance from an object; as objects coast under their own inertia and are acted on by this variable force, they follow paths - or orbits - which display fascinating regularities. We can use many of the concepts we've developed in the course to understand some aspects of these orbits; other aspects will be quite novel. The purposes of this lab are as follows 1) To demonstrate Kepler's three laws of planetary motion; 2) To explore the various quantities used to describe orbits; and 3) To demonstrate how energy and angular momentum are conserved. These three are quite traditional, and also somewhat interrelated. A subtext is 4) To demystify a little the notion of 'computer simulation'. To save time I'm forced to refer you to the book for much of the background material. Please read chapter 15 before coming in. Pay special attention to 15-8 and Here's a useful hint - your lab quiz question will probably be about Kepler's three laws! Please read through the lab at least to Excercise 1, and work it in your notebook before coming to lab. PART A: THE COMPUTER PROGRAM In this part you learn about how the program works by a combination of looking at the theory, working examples on paper, and running a couple of simulations designed to highlight features of the program. We'll be using the computer here to follow the motion of an object under this sort of force. The basic idea is simple; we divide time into little time steps, dt, which are short enough so that not much changes in each step. Then we follow the motion using this sort of algorithm: - given the position and velocity of the object*, - compute the forces acting on the object at that position using f = GMm/r 2 - figure out the object's new position using v(dt) = d; - figure out the object's new velocity using delta v = a(dt) = (f/m) (dt) - go back to the first step. This way we can follow what happens even if it would be difficult to solve for it explicitly * Note for specialists - the genius of the particular scheme used in this program (I didn't invent this aspect, so I can call it that!) is as follows. The velocities are computed for the middle of the time intervals, whereas the positions are for the ends of the time steps. Before the calculation starts, it adjusts the given initial velocity is adjusted appropriately. This makes the calculation much more accurate than it would have been As it turns out, the case considered in this program - simple Keplerian motion (the motion of a small planet or satellite under the influence of a single massive body) actually can be solved explicitly. One of Newton's great triumphs was showing that Kepler's Laws, a set of laws

2 describing planetary orbits discovered empirically by Johannes Kepler in the early 17th century, followed naturally from f = ma and the law of universal gravitation. Some of Newton's proofs are a little too involved for us here, but others can be seen very nicely without complicated mathematics; we'll do that in class. The nice thing about having a simulation program is that you can quickly see that even the hard-to-prove Kepler laws do work out in practice. Along the way you can see how the size, shape, and time-dependence, and other parameters of the orbits follows from their initial conditions. Some of the numbers returned by the program are based on the theory of these orbits, but the orbits themselves simulated in the simple manner described above. The form of the force law used in the computer program is a little obscure at first, so I'll explain it. Gravity acts between any two bodies, exerting an attractive force of magnitude directly on a line between the two bodies; here M and m are the masses of the bodies, G a universal constant (the gravitational constant) which expresses how strongly matter couples to gravity, and r is the distance between the bodies. Since this force acts along the line between the bodies, and since it is attractive, we can rewrite this as If we consider an object moving in the x-y plane, we can find the components of this force easily; this is the form used in the computer program in the lab. There are several other features of the program which it is important to understand. First, the whole calculation is set up in funny (but very convenient) units, which we'll call computer units. These are set up so that GM has a numerical value 1, where M is the mass of the central object. This may look utterly mysterious - we've been stressing mks units all along, and now we're abandoning them! - but it need not be so puzzling if you make it more concrete. To do so, first choose a mass for the central object appropriate to the problem; for the planetary motion problem, this would be the solar mass, 1.99 x kg. Then multiplying out in mks you get GM = (6.672 x m 3 kg -1 s -2 ) ( 1.99 x kg) = 1.32 x m 3 /s 2. For our computer units to work as advertised this must be 1.32 x m 3 /s 2 = 1 (computer length unit) 3 /(computer time unit) 2. So our condition that GM = 1, together with a choice of M, gives a condition on the ratio of the length unit to the time unit. We are still free to choose the value of either; a nice choice might be computer length unit = distance from earth to sun = x m. By substituting in the above expression, you find that with these choices the time unit is constrained to be

3 (1 computer time unit) 2 = [(1.496 x m) 3 / (1.32 x m 3 s -2 )] which gives 1 computer time unit = 5.04 x 10 6 seconds. This looks like a random number, but it's (1 yr / 2π) = (3.156 x 10 7 sec) / 2π = 5.02 x 10 6 sec = days. In other words, the time it takes the earth to orbit the sun should be 2π of our computer time units, and the velocity of the earth in its orbit should be 1 length unit/ time unit. EXCERCISE: In your lab notebook, do a parallel derivation for the following case: M = mass of earth (5.98 x kg) and the length unit = radius of earth (6.38 x 10 6 m). What is the computer time unit in seconds? Convert to minutes. Also, show that in units such that GM = 1, - the circular orbital velocity is the square root of 1/r, where r is the radius in computer units. - EXPERIMENT 1: Using the simulation program*, start the earth off at X = 1, Y = 0, with V x = 0 and V y = 1. How long does it take to go around? * To use it: start the mac, insert the disk, and click the icon 'Kepler4'; after much whirring and clicking the computer program will come up on the screen. You're encouraged to read through it; though much of it is computerese 'housekeeping', you may be able to discern how the actual computations are done. You run the program by pulling down the 'run' scrollbar and clicking on the appropriate choice. A set of axes will appear; the tics are supposed to be one unit apart. As the simulation proceeds you'll see points plotted where the 'earth' is at (more or less) even time intervals. After this is done, follow the directions to see a display all sorts of orbit parameters; look at the 'time period simulated' and the 'period in theory'; do they agree with expectation? As we'll see, the period simulated is not precise but should be close The way points are plotted deserves a little extra attention here. As the time steps go by, they are accumulated into a variable called Tp, the plot time - when this gets larger than a preset value, a point is plotted and the variable is reset to zero. Thus the points plotted are at roughly equal intervals of simulated time; this approximation can break down in some cases, where the variable time steps (explained later) are very coarse, but it is usually pretty good. So where points are plotted close together, the object is going slowly; where points are plotted far apart, the objects are going fast. One feature may have escaped your attention, but it is fundamental! The program does not prompt for the mass of the moving object; it doesn't need it! In computing the orbit, all that the program needs is the acceleration as a function of position; this is independent of the mass of the satellite. To see this, write the force law, set it equal to ma, and cancel m. Now that you've seen the program in action and have some idea what the units mean, it's time to look at it in more detail. As you've seen, the program just starts an object off at some position with some velocity and

4 calculates where it goes. For the 2-body problem, we can restrict our attention the plane in which the object moves; it always stays in the same plane and doesn't move in or out of the screen. Now, how does the program decide to stop this process? You've already seen one way; the program checks to see if the orbit has closed on itself. The way it does this is, after each time step, it compares the present position with the initial position. If it is within a small distance - in particular, the distance the object could move in one time step at its present velocity, with a little extra for slop - it decides it has closed and stops. While the computation is going on, it accumulates the sum of all the little time steps, which is the elapsed time since the start; that's the 'time period simulated' in the printout. This is the normal way for the calculation to stop in the case of a closed orbit. As you'll see as time goes on, in theory all bound orbits close upon themselves and repeat exactly. There's one possible fly in the ointment here - what if the approximations used aren't accurate enough, so the orbit doesn't quite close? Then the program will run on and on forever (or at least for a long time!). This happens rather seldom, generally when an object gets very close to the sun and moves in a very tight curve. If it should happen to you, just pull down the 'stop' item from the 'Run' menu bar, and stop the program. You'll have to restart it then. EXPERIMENT 2: Drop an object into the sun. Start at X = 3, Y = 3, Vx = 0, Vy = 0; this means that it is dropped from rest. Be a little bit patient; don't stop the program. This demonstrates nicely several other features of the program. First, you can easily see how the dots get farther apart as the object falls faster and faster into the sun; and the fact that an object which is dropped heads right for the sun is reassuring! But the newest and most complicated things here revolve around the variable time step. What it does is the following. a) When the simulation starts, it figures out how far the object is from the sun (r 2 = X 2 + Y 2 ), and the speed (V 2 = V x 2 + V y 2 ) and sets the time step dt = 0.01 r / V; in other words, dt is the time it takes the object to go 1/100 of the distance it is from the sun. (This doesn't mean that r changes by 1/100 in the first step, unless the object just happens to start out heading directly toward or away from the sun.) b) After each step, it compares the current value of r to the current value of V; if the time step is such that the object is moving more than 0.02 r in a time dt, it decides that the time step is too coarse, and it halves the time step. If the time step is such that the object is moving less than r in time dt, it decides that the timestep is too fine, and it doubles the time step. Since it takes the computer a (more or less) fixed amount of real time to do one step, this means that the execution can speed up or slow down a lot compared to the time we're simulating in the system. As the object drops into the sun, for example, it takes a large amount of actual time to simulate the last plunge of the object into the sun, which (if you were to do it) would take place very quickly. As you just saw, there is a limit to how many times this adjustment can take place! If during the execution the time step is halved more than 15 times, the computer decides that it's not worth proceeding and quits. It actually keeps track of the net number of adjustments, counting upward ones as positive and downward as negative; if this gets to be less than -15, it kicks out. This saves the program from running indefinitely. Let's see another aspect of this variable time step and demonstrate something else as well. EXPERIMENT 3. As we've seen in class, if you fire off an object with more than root-2 times its circular orbit velocity, it never comes back! Try it; the circular velocity at X = 1 unit is 1; try launching an object with X = 1, Y = 0, V x = 0, and V y = 1.5. Again, be a bit patient. As you can see, the object goes off the visible part of the screen into never-never land; it in fact does

5 not come back. Yet the program still stops; there's a limit of 200 length units for r and the program kicks out once this is exceeded. So some very large closed orbits cannot be simulated, but once again execution terminates in an orderly fashion. This is all the termination modes we have: - the orbit closes on itself - the time step gets excessively short - the object gets too far from the center. There's another sweet aspect of the program demonstrated here. As you can see from the 'time period simulated' parameter, the object has taken an awfully long simulated time to get out to r = 200! Yet the execution time was not excessive. If you think about it, with the object heading more-or-less straight away from the sun, and the time steps adjusted as the program does, it takes about 100 time steps - loops through the program - for the distance from the sun to double. These 100 time steps take maybe 1 second to compute. In the next second, the distance doubles again, and then again, and so on. So the execution time goes down exponentially as the object gets away from the sun, which means it gets to the 200 unit limit in pretty short order. PART B: KEPLER'S THREE LAWS. EXPERIMENT 4: Kepler's first law: The planets move in elliptical orbits with the sun at one focus. This is a little hard to demonstrate, especially since most people have only a faint idea of what an ellipse is! So here's a way to do it. The person working on the Mac connected to an Imagewriter should simulate an orbit which is nicely closed and fits on the screen, which is oblong. A little experimentation will give you a good one; you might start at x = 1.5, y = 0, vx = 0, and vy a little more than the circular velocity. This person dumps the screen to the imagewriter by typing CTRL- SHIFT-4, all at once; the 'CTRL' key is the funny little four-leaf clover guy at the lower left. Someone gets to go make expanded copies of this, enough for each pair of people in the lab. Mount this on a board with pins through the two foci of the ellipse. (One is at the 'sun'; where is the other?) Get a piece of string and tie it so that when pulled around the two pins, it just reaches the curve. Trace the ellipse with a pencil. An alternative, higher-tech but less pedagogical way: dump the screen to a MACPAINT document using CTRL-SHIFT-3; then use the MACPAINT ellipse drawing utilities to maneuver an ellipse to match the curve EXPERIMENT 5: A line drawn from the sun to a planet sweeps out equal areas in equal times. As can be seen from Fig in the book and the discussion on pp , this is exactly equivalent to saying that the angular momentum of a planet with respect to the sun is conserved. This must be so since the force acts directly along the line of centers, and hence creates no torque on the planet when the origin is taken as the sun. To demonstrate this, I've built another feature into the program. After you've run a simulation, one of the choices that usually comes up is 'type 1 to see stored values'. While the program executes, it randomly stores the x, y, vx, vy values of up to three point in the orbit. The points to be stored are selected at the 'throw of a dice' and are completely typical. (If no values happen to be stored, you don't get the choice.) To do this part, then, a) run a simulation of a somewhat elliptical orbit b) look at the values stored. Check to be sure that the points selected are not too tightly clustered around the orbit; the best case is to have one fairly close to the sun and one rather far a Once you get a good run, select two points and c) Accurately copy the x, y, vx, vy values; get the digits right. d) In your notebook, sketch the orbit moderately accurately and graph where two of the selected points are.

6 e) Below this, graph the velocities at these points as vectors in the (Vx, Vy) plane. f) Transfer these up to the first graph. Find the angles between the vectors with a protracter. g) Compute the lengths of the vectors using the Pythagorean theorem. h) Compute the magnitude of cross product of r and v, or r v sin θ; this is just the angular momentum per unit mass, since l = r x p = r x mv) That was laborious, wasn't it! Here's the easy way: The cross-product here can (it turns out) be written as r x v = (x i + y j) x (V x i + V y j) = ( x V y - y V x ) k so the rest of it is i) Compute the cross-product the easy way! In this way, demonstrate that angular momentum is conserved! EXPERIMENT 6: Kepler's law of periods and distances. Start by simulating circular orbits at 1, 2, and 3 units distance; refer to the first excercise for guidance about initial conditions. Since the 'Period in theory' numbers are derived from the theory, and we want to test it, use the 'Time period simulated' numbers to show that T 2 /r 3 = a constant; what is that constant for these uints? Now, simulate a couple of elliptical orbits. Look at their values of a (the semi-major axis) when the parameters come up. Satisfy yourself that these numbers are reasonable for the orbit plotted. Again, compute T 2 /a PART C: Orbits and Energy; Parameters of the Conic Sections. EXPERIMENT 7. Run the following orbits, all starting from (x = 1, y = 0, V x = 0) and varying V y. Keep a table of (a) period, (b) total mechanical energy, (c) angular momentum, (d) semimajor axis; (e) orbital eccentricity. Between runs, elect to 'keep' the graphics, so that it overplots. Sketch in your notebook what happens in each case. Also write down the (x, y, vx, vy) for one of the randomly recorded points. The cases are: (a) vy = 0.5; (Where's the focus without the sun in it?) (a) vy = 1; (b) vy = 1.2 (Now where's the focus without the sun?) (c) vy = 1.41 (d) vy = = root 2; for this and the following note down the (x, y, vx, vy) of the stopping point, and note the 'time period simulated'. Note that there's no 'period in theory' - why not, do you suppose? (e) vy = ; (e) vy = 1.5 (f) vy = 3.0

7 In your notebook, answer the following: - How does the eccentricity behave as the energy increases? What happens around e = 0? The eccentricity is a measure of how 'out of round' a conic section is. e = 0 for a circle, e < 1 for an ellipse, e = 1 for a parabola, and e > 1 for a hyperbola. Here we see a generalization of Kepler's first law; the planets may move in ellipses, but even unbound orbits are conic sections. Now do the following. As you'll recall, the gravitational potential energy is U = - GMm / r, And of course kinetic energy is K = 1/2 mv 2. Gravity is a conservative force, so for any of these orbits we should have E mech = K + U = constant. And as we've seen, if an orbit has E mech > 0 it is unbound; if it has E mech < 0 it is bound. The E reported here is computed on the basis of the initial conditions. Now for each of your bound orbits compute E at your randomly-stored point; with these convenient units it's just E = -1/ (root (x 2 +y 2 )) (V x 2 + V y 2 ). For each of your unbound orbits, compute E at the stopping point. This should be conserved fairly well, but as it turns out the approximations don't conserve E as well as they do angular momentum. Notice the obvious relationship between the orbit's starting parameters and the angular momentum. Can you understand it in terms of the definition of angular momentum (per unit mass)? That's the end of the formal part of the lab. You may want to play some more by modifying the computer program. You're encouraged to do this, but make your own copy of the program before modifying it. One thing to try would be changing the exponent in the force law, which appears in the 'meat of the calculation', the program loop in which the object is followed. This will lead to several consequences which you should be aware of; (a) the orbit parameters reported after each simulation won't be correct; (b) bound orbits may not close on themselves, so the program won't stop. You might invent an appropriate fix for this.