Chapter 1 is a lot of review for my second-year students. The new bit is relativistic momentum, and the revelation that our definition of momentum from last year was really just a special-case limit.

One of my themes for the year is 'pulling back the veils' on all of those more complicated bits that we approximated and hand-waved away last year. I want this to be a major selling point of the course. Unfortunately, as presented, I think that the momentum definition isn't accessible or real to the kids. We can't really discover it, and it's just an abstraction at first.

I wrote a VPython program to give this some context. You can run it twice for the students - in each case, a 60 g block is pushed from rest by a constant 1 million Newton force. The momentum and velocity of the block are graphed as time goes on.

Here's where another pillar of the course is going to come in to play: fundamental laws of the universe. Really, we didn't deal with too many last year, at least not on a really visceral and important level. Here, though, the universal speed limit becomes important. Look at the v graph pass right by it without blinking, when the program uses the classical definition of p (and finds v from there):

That's a problem. The problem's with our model, though: momentum just doesn't

*really*equal mass times velocity. Uncomment the gamma definition in the program to use the real relationship now:
Here's a great way to distinguish which is the fundamental principle here: the momentum principle still holds just fine, even in the relativistic case, but our definition of v (as determined from the momentum) was broken. With the relativistic relationship, the velocity approaches the universal speed limit. Two days in and kids not only know a fundamental law of the universe, but they know how it really does fit in with what they knew about momentum and what the missing piece in their model was.

Script:

```
from __future__ import division, print_function
from visual import *
from visual.graph import *
scene.background = color.white
scene.height = 50
scene.width = 50
scene.x = scene.y =0
## Josh Gates 2012, started with kernel of Ruth Chabay program
print ("""
Click anywhere in display window to start.
Click to stop.
Momentum and velocity are shown as .6 kg block is pushed with a constant 1,000,000 N force.
Uncomment gamma line to remove classical p def'n/assumption""")
## CONSTANTS
delta_t = 0.01 ## for 100 steps
mblock = 0.06
c=3e8
Fnet = vector(1e6,0,0)
## OBJECTS & INITIAL VALUES
pblock = mblock*vector(0,0,0)
gamma = 1
# start time at 0
t = 0
scene.center = (0,.1,0) # move camera up
scene.range = 0.15
## GRAPH STUFF
gp = gdisplay(background=color.white, foreground=color.black, y=0, x=250, height=300,
title='Momentum vs. time: block with constant F', xtitle='Time (s)', ytitle='Position (m)',
ymax=3e7,xmax=30)
blockp = gcurve(color=color.magenta)
blockp.plot(pos=(t,pblock.x)) ## initial pos.x of block
gv = gdisplay(background=color.white, foreground=color.black, y=300, x=250, height=300,
title='Velocity vs. time: block with constant F', xtitle='Time (s)', ytitle='Velocity (m/s)',
ymax = 3e8, ymin=0, xmax=30)
blockv = gcurve(color=color.blue)
blockv.plot(pos=(t,pblock.x/(gamma*mblock))) #initial velocity
asymptote=gcurve(color=color.red)
scene.mouse.getclick()
stopper='go'
a=.1
while a<1000:
asymptote.plot(pos=(30/a,3e8))
a=a+1
## CALCULATIONS
while stopper=='go':
rate(500)
pblock = pblock + Fnet*delta_t
# comment to make classical approximation
#gamma = (1-(pblock.x)**2/(mblock**2 * c**2+(pblock.x)**2))**-.5
# update time
t = t + delta_t
# plot pos.x, velocity.x of block
blockp.plot(pos=(t,pblock.x))
blockv.plot(pos=(t,pblock.x/(gamma*mblock)))
## print t, block.y
if scene.mouse.clicked:
stopper='stop'
```

I love the idea of showing the difference beteween relativistic and non-rel momentum using a VPython program. This really gets to some big ideas that we want students to see about computational thinking—that they use the program to explore the behavior of physical laws in situations they couldn't possibly recreate, and that a few small changes to the laws underlying a program can produce wildy different responses. I also think this would hit home the idea of the non-rel approximation of momentum being a good approxiamation at low speed much more nicely than just a handfull of well chosen calculations. It'd be easy for students to add a plot showing how big the difference is as the speed increases.

ReplyDelete