• Use mathematical representations to support the claim that the total momentum of a system of objects is conserved when there is no net force on the system (HS-PS2-2)

• Units
  • Dimensional Analysis
• Newton's Laws of Motion
• Conservation of Momentum
  • Elastic Collisions
  • Inelastic Collisions

• Cut/Copy Code.
• Modify existing code
  • Colliding Crates

Inelastic Collisions

In this activity, you will be asked to complete several tasks involving what you have learned about conservation of momentum and the interaction between masses when they collide and applying this knowledge to actual computer program code.

A football scenario…….

During a Friday night high school football game, two rival schools are locked in a heated battle with the score only 10-6. It’s 4th and goal from the 1 yard line with 2 seconds left on the clock. Buff, a 3 star football linebacker, whose mass is 100 kg, is running towards the goal line head on with a velocity of 8 m/s. Biff, the 4 star running back on the other team(who is down by 4 points), with a mass of 80 kg, is moving with a velocity of 12 m/s as the ball is handed off to him and he jumps over the line of scrimmage attempting to score a touchdown. Buff makes a tackle on Biff in midair and they then move together.

1. Determine the momentum of each player: (Pay close attention to the direction of your momentum vector.)
2. Find the total momentum of the Biff-Buff system before and after the collision:
3. What is the final velocity of Biff and Buff while still in mid-air?
4. Whose team wins the game: Biff's or Buff's?
5. Now modify your Colliding Crates program to fit this scenario

Link

GlowScript 2.7 VPython
 
#Creating the objects
floor = box(pos=vector(0,-30,0), size=vector(100,4,12), color=color.white)      #I've created the floor that the crate will slide across
crate = box(pos=vector(0,0,0), size=vector(20,20,5), color=color.red)           #I've created the crate, along with its dimensions and initial position resting on the floor
 
#Setting the time interval
t=0                                                                             #I've set the initial time to zero.
tf=0.940                                                                        #I've set the final time to 0, which gives the crate enough time to slide across the floor
dt=0.01                                                                         #I want my time interval set at 1/100th of a time unit
 
#Creates velocity vectors as a function of time
get_library('https://rawgit.com/perlatmsu/physutil/master/js/physutil.js')      #The program needed to know what a motion map is defined as
motionMap = MotionMap(crate, tf, 5, markerScale=0.1)                            #I want to display 5 arrows showing the motion of the crate
 
#Giving the objects an initial velocity
cratev=vector(75,0,0)                                                           #I'm defining the constant velocity of my crate to be 75 in the x-direction(left to right)                                       
while crate.pos.x<35:                                                           #I want the crate to stop before it slides off the floor
    rate(50)                                                                    #This rate can speed up or slow down the replay
    crate.pos=crate.pos+cratev*dt                                               #I'm moving the crate by adding the change in position (cratev*dt) to the previous position (crate.pos)
    t=t+dt                                                                      #I'm updating the time
 
#This updates the velocity vectors
    motionMap.update(t,cratev)                                                  #This updates the motion map and display of the arrows as the crate slides across the floor
 
#This creates the graph of the kinetic energy of the crate
#f1 = gcurve(color=color.blue)                                                  #Setting up a graph to show the kinetic energy of the crate as a function of time
#for t in arange(0, 0.94, 0.01):                                                # Time goes from 0 to 0.94 in 0.01 time intervals
#    f1.plot(pos=(t,cratev.mag**2))

1. Using the equation for momentum $\vec{p} = m\vec{v}$, we can plug in the known information to find Buff and Biff's respective momenta
   1. $\vec{p}_{Buff} = (100 \text{kg})(-8 \text{m/s}) =-800 \text{kg·m/s}$
   2. $\vec{p}_{Biff} = (80 \text{kg})(12 \text{m/s}) =960 \text{kg·m/s}$
2. We can find the total momentum by simply summing the momenta of Buff and Biff $\Sigma\vec{p}=\vec{p}_{Buff}+\vec{p}_{Buff}$
   1. Before: $\Sigma\vec{p}=-800 \text{kg·m/s}+960 \text{kg·m/s}=160 \text{kg·m/s}$
   2. After: Due to the law of conservation of momentum, the total momentum of the Biff-Buff system before and after the collision should be the same. Therefore $\Sigma\vec{p}=160 \text{kg·m/s}$
3. Since the football player's collision is assumed to be perfectly inelastic (they stick together), they will have the same velocity. We can find this velocity by dividing their combined momentum that we just calculated in Question 2 by their combined mass: $\vec{v}= \dfrac{\Sigma\vec{p}}{m_{Buff}+m_{Biff}}$
   1. $\vec{v}= \dfrac{160 \text{kg·m/s}}{100 \text{kg}+80 \text{kg}}=0.89 \text{m/s} $
4. From the velocity calculated for the previous question, we can see that Biff and Buff will move in a positive direction—to the right. They are only 1 yard (0.91 m) from the end zone, so if all goes well, Biff will score a touchdown and win the game 12-10 with less than a second to spare.
5. See below

Link

GlowScript 2.7 VPython
 
#Creating the objects
floor = box(pos=vector(0,-30,0), size=vector(160,4,12), color=color.white)      #I've created the floor that the crate will slide across
crate1 = box(pos=vector(-40,-20,0), size=vector(20,20,5), color=color.red)      #I've created the crate, along with its dimensions and initial position resting on the floor
crate2 = box(pos=vector(40,-20,0), size=vector(20,20,5), color=color.blue)
crate1m = 80
crate2m = 100
#Setting the time interval
t=0                                                                             #I've set the initial time to zero.
tf=10                                                                           #I've set the final time to 0, which gives the crate enough time to slide across the floor
dt=0.01                                                                         #I want my time interval set at 1/100th of a time unit
 
#Creates velocity vectors as a function of time
get_library('https://rawgit.com/perlatmsu/physutil/master/js/physutil.js')      #The program needed to know what a motion map is defined as
motionMap1 = MotionMap(crate1, tf, 5, markerScale=0.1)                          #I want to display 5 arrows showing the motion of the crate
motionMap2 = MotionMap(crate2, tf, 5, markerScale=0.1)
 
#Giving the objects an initial velocity
crate1v = vec(12,0,0)
crate2v = vec(-8,0,0)
while crate2.pos.x-crate1.pos.x>20 and crate2.pos.x<70 and crate1.pos.x>-70:    #I want the crate to stop before it slides off the floor
    rate(50)                                                                    #This rate can speed up or slow down the replay
    crate1.pos=crate1.pos+crate1v*dt                                            #I'm moving the crate by adding the change in position (cratev*dt) to the previous position (crate.pos)
    crate2.pos=crate2.pos+crate2v*dt
    t=t+dt                                                                      #I'm updating the time
 
#This updates the velocity vectors
    motionMap1.update(t,crate1v)                                                #This updates the motion map and display of the arrows as the crate slides across the floor
    motionMap2.update(t,crate2v)
 
while crate2.pos.x<70 and crate2.pos.x-crate1.pos.x<=20 and crate1.pos.x>-70:  
    rate(50)
    crate1v = (crate1m*crate1v+crate2m*crate2v)/(crate1m+crate2m)               #This determines the velocity of crate1 by dividing the total momentum by the total mass
    crate2v = crate1v
    crate1.pos=crate1.pos+crate1v*dt                                            #I'm moving the crate by adding the change in position (cratev*dt) to the previous position (crate.pos)
    crate2.pos=crate2.pos+crate2v*dt
    t=t+dt

—-