Question (1320001)
The net force on a dart in a spring-loaded dart gun.
A spring-loaded dart gun is used to shoot a 5-gram dart straight upward. Its spring has a stiness 50 N/m,
and its relaxed length is 5.0 cm. The spring is compressed 4.0 cm from its relaxed length. What is the
velocity of the dart when it leaves the spring (i.e. at the instant the spring returns to its relaxed length)?
Apply the Momentum Principle iteratively in order to answer the question.
Solution
Use an iterative approach to answering the question. In other words, write a program that calculates the
net force on the dart, its momentum, and its position in small time steps (i.e. small time intervals). The
easiest way to do this is to write a program, perhaps in Python.
In an iterative loop, the program should do the following for each object in the simulation:
(1) Calculate the (vector) forces acting on the object and sum the forces to calculate the
object.
net force on the
(2) Update the momentum of the object: p~f = p~i + F~net ∆t.
(3) Update the position of the object ~rf = ~ri + ~vavg ∆t, where the average velocity can be approximated as
p
~f
∆t . (Note: there are more accurate ways to approximate the average velocity.)
~vavg =
(4) Update the clock reading, t = t + ∆t.
The loop repeats, performing each of the calculations above for each time step, ∆t.
You can use a condition in the while loop or an if statement to stop the loop and print the position and
momentum of the dart. Or, you can simply print the position and momentum of the dart in an innite
loop and after enough iterations, manually stop the simulation and examine the data in order to answer the
questions.
Begin by drawing a picture of the situation, with a coordinate system. This is important for determining
the initial position of the dart, for example.
While we can certainly develop realistic graphics in the simulation, let's begin with a simple simulation that
does the correct calculations, but without fancy graphics. Thus, the simulation will model the dart as if it's
a sphere and will only show the dart and the base of the barrel of the dart gun. In addition, we'll dene y
= 0 to be the center of the ball when it leaves the dart gun.
The initial position and initial velocity of the dart is:
~ri
= < 0, −0.04, 0 > m
~vi
= < 0, 0, 0 > m
The initial amount that the spring is stretched is:
Figure 1: A dart as it is launched from a dart gun.
Figure 2: A simple model for the dart gun.
|s| =
0.04 m
Because of our choice of coordinate system, it is convenient that the distance stretched is equal to the
negative of the dart's y position.
|s| = −yi
This allows us to write the force by the spring on the dart as
F~by
spring on dart
= < 0, ks |s|, 0 >
= − < 0, ks yi , 0 >
= −ks < 0, yi , 0 >
= −k~ri
But this holds true for any position of the dart/spring system, not just the initial position. Thus, while the
dart is in contact with the spring,
F~by
spring on dart
= −k~rdart
The above relationship between force by the spring on the dart and the position of the dart is only valid because of our choice of the coordinate system. If we did not choose our coordinate system so conveniently, then
you would have to explicitly calculate the distance the spring is compressed at any instant during the motion.
Now, draw a free-body diagram and write the net force on the dart.
Figure 3: A free-body diagram for the dart.
The net force on the dart is
F~net
= F~
by spring on dart
+ F~grav
by Earth on dart
= −k~rdart + m < 0, −g, 0 >
Now that we have the expression for the net force on the dart and now that we have its initial conditions, we
can write the simulation. Here is an example program in Python to simulate the motion of the dart. This
program does not show the spring.
1
2
3
4
5
#Simulation of a dart launched v e r t i c a l l y from a dart gun
from v i s u a l import *
#set the scene so vpython won t autoscale as we watch the animation
'
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
s c e n e . a u t o s c a l e=0
s c e n e . range =0.1
#create the dart and the base of the dart gun ; the dart is shown as a sphere
dart=sphe re ( r a d i u s =0.01 , pos =(0 , − 0.04 ,0) , c o l o r=c o l o r . y e l l o w )
base=box ( pos =(0 , − 0.06 ,0) , s i z e = ( 0 . 0 1 5 , 0 . 0 0 2 , 0 . 0 1 5 ) , c o l o r=c o l o r . white )
#define constants
k=50.0
#N/m
g=v e c t o r (0 , − 9.8 ,0)
#m/s^2
m=0.005
#kg
#define i n i t i a l conditions
dart . pos = v e c t o r (0 , − 0.04 ,0)
dart . v = v e c t o r ( 0 , 0 , 0 )
dart . p = m* dart . v
t = 0
dt = 0 . 0 0 0 5
#print a header for data
print " time ( s ) " , "\ t " , " p o s i t i o n (m) " , "\ t " , " v e l o c i t y (m/ s ) "
#stop the loop when the y− position of the dart reaches zero
while dart . pos . y < 0 :
rate (10)
Fspring = −k * dart . pos
Fgrav = −m* g
Fnet = Fspring + Fgrav
dart . p = dart . p + Fnet * dt
dart . v = dart . p/m
dart . pos = dart . pos + dart . v * dt
t = t + dt
print t , "\ t " , dart . pos , "\ t " , dart . v
The last four data points printed are:
time (s)
0.014
0.0145
0.015
0.0155
position (m)
velocity (m/s)
< 0, −0.00496943, 0 >
< 0, −0.00293469, 0 >
< 0, −0.000890157, 0 >
< 0, 0.00115905, 0 >
< 0, 4.03974, 0 >
< 0, 4.06948, 0 >
< 0, 4.08906, 0 >
< 0, 4.09841, 0 >
Table 1: Position of the dart as it is launched, before it leaves the spring.
The dart leaves the spring during the interval between t = 0.0150 s and t = 0.0155 s. Its y-velocity when
leaving the spring is about 4.1 m/s, rounded to two signicant gures.
It's important to solve this problem iteratively because the net force on the dart is NOT constant. This is
apparent by graphing the y-momentum as a function of time. It is not linear. If the y-component of the net
force on the dart were constant, then the y-momentum vs. time graph would be linear.
Figure 4: A graph of y-momentum vs. time for the dart. Note that it is not linear.