Liquid Metal and Inelastic Collisions

Sorry to hit you all with this again, but I have updated a few calculations and made some interesting new observations.
A friend sent me a link to a website with an interesting new material called liquid metal. They have a video of a steel ball bearing bouncing on a plate of this metal, which shows the material’s surprising elasticity. The steel ball bounces for much longer than on a similar plate of titanium or steel.
The bouncing sound was somewhat like a metronome. Except that I noticed that the time it took for the ball to bounce got shorter the longer it bounced. So it starts out going ping — ping — ping — ping quite regularly but after a while it is faster, ping — ping — ping — and eventually is bouncing so quickly it sounds like a buzzing noise.
The ball bearing appears to be behaving as an oscillating spring with a decay. But what kind of decay? Was curious.
So I found an application called Wire Tap Pro” which has a 30 day free trial. I recorded the audio track of the bouncing ball bearing and opened it in sound studio.
bouncing_sound_studio.png
I took a few data points from the audio track. I selected an interval of ten bounces, and sampled about every five seconds through the 40 second recording. I added one last point at the end at the best resolution I could discern (it got hard to read because the bounces got quieter and closer together).
I typed the data into a text file using my favorite text editor, vim.

 1  start   end
 2  0.134   2.635
 3  4.969   7.146
 4  9.956   11.813
 5  15.180  16.695
 6  19.969  21.211
 7  25.043  25.957
 8  29.986  30.613
 9  34.982  35.291
10  36.424  36.637

What I really wanted to plot was the time since ball was released on the X axis, and duration of the bounce on the Y. So I needed to plot the average of the start and end time versus the average of the duration. I used perl, my digital swiss army knife, to convert this file.


1  perl -pi.bak -e 's[([\d.]+)\t([\d.]+)][($1+$2)/2.0 . "\t" . ($2 - $1)/10.0]e;s/start/time/;s/end/duration/;' bounce.dat

This resulted in converted data:

1  1.3845  0.2501
2  6.0575  0.2177
3  10.8845 0.1857
4  15.9375 0.1515
5  20.59   0.1242
6  25.5    0.0914000000000001
7  30.2995 0.0626999999999999
8  35.1365 0.0308999999999998
9  36.5305 0.0213000000000001

This I could plot using GNUPlot and this plot file:


set term postscript eps color 48;
set output "test.eps";
set size 3.2,5.2;
set origin 0,0;
set multiplot;
set size 3,5;
set origin 0.1,0.1;
set pointsize 20;
set xlabel "time since release (s)";
set ylabel "duration (s)";
f(x) = a*x + b
fit f(x) '/Users/arahn/bounce.dat' via a,b
set xtic rotate by -45;
set title "Bouncing Of a Steel Ball Bearing";
plot f(x),'/Users/arahn/bounce.dat' with points pt 7 ps 3 ti "liquid metal";

To get this pretty graph:
bouncing_graph.png
gnuplot also gave me the regression values, intercept of 0.256846 s and slope of -0.00645081 s/s. This means that each bounce lasts 99.354919% as long as the bounces in the previous second. I was amazed at how well the data fit the regression line!
I would expect that decay would act on the total energy of the system — but we’ve shown that it correlated with the duration of the bounce. However, the tricky part is that you can’t really draw any conclusion based on how the duration of the bounce correlates with how long ago the ball was released. Energy is lost when the ball strikes the ground. As time goes on, it is striking the plate more and more often. What I’d really like to do is correlate the how many times it has hit the ground with how much energy it has. My hypothesis is that it would be an exponential decay in energy with respect to each bounce.
To determine how many times the ball has hit the ground, we could count them all. Or we could use calculus. The integral of the rate (clicks per second) is a function determining how many clicks have passed at time t.

click duration = d = mx + b
click rate = 1 / d = 1 / (mx + b)
num clicks = N = integral ( 1/ (mx + b) ) evaluated from zero to t
N = ( ln( mt + b ) - ln( b ) ) / m


We can turn that around to find out how the duration of a click is related to the number of times the ball has bounced:

m N = ln( d ) - ln( b )
d = b em N


I went back to see if this new data jives. We expect the first click (index zero) to have a duration of b, or 0.257 seconds. The first bounce in the audio recording is 0.261 seconds. Here is a table comparing the actual bounce times versus expected:

1  hit_num actual_time computed_time
2  0   0.261   0.257
3  10  0.242   0.242
4  20  0.228   0.227
5  30  0.212   0.213
6  40  0.197   0.199

Outstanding! The numbers are almost identical. Before you berate me for whimping out after 40, keep in mind what a nuisance it is to try and count all the blips in the recording.
Let see, we also know that the click duration is equal to the velocity (in meters per second) divided by the acceleration of gravity (G). Thus

velocity = b G em N


Here my hypothesis is wrong : Energy is proportional to the square of velocity. But we’ve shown that the duration of each bounce is proportional to velocity, and therefore the square root of energy. This reveals something interesting about inelastic collisions that I didn’t realize before.
An experiment for next time: We’ve shown that the amount of energy lost each time the ball strikes the plate is proportional to how quickly the ball strikes the plate. I wonder if the amount of noise that it makes is proportional to either the speed, or the energy with which it strikes? We could use the same sound recording to look at the size of the sound wave and relate it to how closely together the clicks occur.

Leave a Reply

Your email address will not be published. Required fields are marked *