This brings a couple of important notes.

First, this will obviously be my last post at scienceblogs.com. You might want to change your blogroll and rss reader to the new address:

http://www.wired.com/wiredscience/dotphysics

And RSS feed at http://www.wired.com/wiredscience/category/dot-physics/feed

Note that other than the address and different banner, everything will pretty much be the same.

Second, I would really like to thank ScienceBlogs for the opportunity to be a part of such a nice group of bloggers. Really, I have learned a lot. Also, I want to be clear that I have no problems with ScienceBlogs. Why move then? I think that being at wired.com will give me different opportunities. One of my goals as a blogger is to bring the cool stuff in physics to lots of people. ScienceBlogs is great, but it seems like it is aimed more towards a science audience than wired.com.

Anyway, I am pumped up about the move. Hopefully, I will see you over there. I assume there will be some sort of official announcement at wired.com/wiredscience.

]]>There is a threaded plug on the top. I took it off so you could see inside. The whole thing is pretty heavy.

Good luck, and let’s be careful out there.

]]>Watermelon smashed on face. Wow. What can I we calculate here? Bring in the video analysis.

First, this is not a very good quality video. The frame rate sucks and there is a very slight panning and zooming (which I will ignore) Second, I really don’t have anything to scale the video so I just assumed the girl-launcher was about 1.5 meters tall. Just a guess. Using Tracker Video analysis, I get the following data (where the x-direction is along the direction of motion of the melon):

This shows the motion of the melon both while being launched and when coming back. The first thing I did was to fit a parabola to the very beginning motion. This will give me the initial acceleration with a value of about 120 m/s^{2}. Zowza.

I can also get an estimate for the initial and final velocity by fitting a linear function to the data. Note – the melon is actually accelerating (due to the gravitational force) but it is moving so fast, I can ignore this. Doing so, I get a launch speed of about 15 m/s and a returning speed of also about 15 m/s (this is good). First, if the melon gets stuck in the launcher then it should have the same return speed that it had launching (energy conservation). Also, 15 m/s seems like a reasonable speed (around 33 mph).

This is a little bit more complicated. First, there is the initial impact and then there is the recoil of the head. Here is a plot of the head as a function of time (mostly in the direction of recoil)

I guess the first thing to do would be to estimate the acceleration of the head. This is where you would get an injury, if the acceleration was too high. Really, there is only a couple of frames with the head getting hit. I don’t think I can get that from video. But I can get it, oh yes, I can. All I need from the video is the recoil distance. Let me say that the head recoils a distance of 0.2 meters. The other thing I need to know is the final speed of the melon. No clue here. Let me just say that it is going half as fast as it was when it hit (the pieces of the melon are still moving after the collision).

Here is a diagram of the melon at the beginning and at the end of the collision:

Since everything is in the same direction, I can use the scalar-kinematic equation:

Using an initial and final velocity of 15 m/s and 7.5 m/s as well as a distance of 0.2 meters, I get an acceleration of 422 m/s^{2} (oh, this is the average acceleration). This is about 43 g’s. Clearly enough to smash the melon. What about the head? Does that mean the head had the same acceleration? No. First, it has a different mass. Second, it is connected to the rest of the body so that there are other forces on it.

Perhaps with a better quality video, I could get a little more detail.

]]>In order to just get something done, I set up the “shoot the falling target” demo. (previously known as shoot the monkey). Here is a quick video demo (seriously – first take too).

What is going on here and what does this have to do with g? Well, it doesn’t really have anything to do with g, but it is a cool demo (meaning this demo would still work on the moon). The basic idea is that you aim a projectile launcher straight at a hanging target. When the ball is launched, the target drops and the ball collides with the target in mid-air.

Why does this work? Let me start with a diagram.

I guess it is clear, but the vector v_{0} is the initial velocity of the ball aimed at an angle θ at a target that is a distance s horizontally away and a height h above the launcher. But why do they hit? Let me start with the ball. (here is a quick projectile motion review) The ball’s motion can be broken into an x-direction motion and a y-direction motion with the following initial velocities:

Two quick notes: I am using v_{0} to represent the magnitude of the initial launch speed. Also, the x-velocity does not change (no forces in the x-direction) so that I can just call it v_{x} instead of v_{x0} (of course, the y-velocity does change). Using those velocities, I can get position-time functions for both directions.

There is the “g”! Also, I am assuming the ball launches at time t= 0 seconds from a position x_{0} and y_{0}. Now, what about the target? The target also starts falling at t = 0 seconds, but its initial position is (x_{0} + s,y_{0} + h) as seen in the diagram. There is no x-direction motion for the target, so I can just write:

I am calling y_{m} is the y position of the target as a function of time. The target’s initial velocity is zero. First question: what time will the ball be at the x-coordinate of the target? Going back to the function for the x-position of the ball,

And what will be the vertical position of the ball at this same time?

What about the target? Where will the target be at this same time?

Notice that the only difference between the y position of the target and the ball is that the ball has a “s tan(θ)” where the target just has an h term. Oh but wait. Look back at the original diagram and you will see that:

What does this mean? This means that at the time when the ball reaches the x-position of the target **the ball and the target have the same y-position**. If two things are at the same place at the same time, they hit. Boom.

Notice one cool thing – the value of the magnitude of the initial velocity does not matter (unless the ball hits the floor before it gets to the target). The only important thing is that the ball is aimed at the target. This means that θ for the velocity vector is the same θ for the geometrical set up of the target.

Wait! There is more! How about a nice python-generated graph? This is pretty simple to set up really. In python, I will model the shot ball and the falling target.

That is with a launch speed of 6.5 m/s. What if I increase the speed to 8 m/s?

You can’t really see that the two paths cross at the same time. Let me draw fewer points.

There, that is with a time step of 0.1 seconds. The points are numbered and you can see that the two points labeled 4 are right next to each other.

That is it for g-day. I will have bigger plans for next year.

]]>Here is the original item:

It is of course a gas discharge tube. You put these tubes in there (as shown above) with helium or neon or whatever in there and it excites the gas to give off light.

Honestly, we have like 10 of these things laying around. Some of them are newer and say “Danger 5000 volts”), but these older ones say nothing. Here is an example of one of the first ones I saw.

I didn’t figure out what it was for a while because most of the ones we have don’t have those metal clips that hold the tube – just two posts sticking up.

This seems like a super dangerous design. For comparison, here are two other models (that we actually use).

The one on the left is the older one (isn’t it obvious). You could stick your fingers in the two white tube holders and shock yourself, but you would have to try. The newer one is pretty much safe for toddlers. The only dangerous part of the newer one is that you could drop it on your foot. Of course you can’t even change the bulb.

]]>First, there is the lower, easier to consume version from io9.com

Physics forced to come up with whole new equation to explain “impossible” soccer kick

I will summarize this article for you:

“Have you seen these crazy soccer kicks where the ball curves? It happens because the ball spins and physics. Here is a video”

Oh, and they have a diagram – which doesn’t seem to come from the original paper and they also have some nifty real-life soccer videos. I think this story is a little too light on the details. They could have done just a little bit more to make this a much better article. Essentially they said that the ball curves because of magic (but magic is physics).

Then, there is the original article on the motion of spinning objects (which talks about soccer at the end) from the New Journal of Physics – IOP:

The spinning ball spiral – Guillaume Dupeux, Anne Le Goff, David Quéré and Christophe Clanet

Let me select one tiny part of the paper to show you: (they used pictures for some of the variables, so some of this might not appear exactly as the author intended – but you will get the idea):

“The motion of the sphere of mass M is described in the Serret-Frenet coordinate system introduced in figure 2. We first focus on the direction . The Reynolds number Re = ρU0 R/η is of the order of 104, which implies a drag F1/2ρU2πR2·CD, with CD0.4 [28]. The equation of motion along thus is written as”

They lost me at “Serret-Frenet” coordinate system. So, this doesn’t appear to be consumable for the more general audiences.

**Update:** While looking for some soccer ball data, I found a third article. The first was too cold, the second was too hot, but this one was just right for Goldilocks. This is from physicsworld.com.

Like I said, I think this last article gives a better mix of understandablity and physics.

I am going to try to fill in the middle between the io9.com article and the original article. I might fail, but I am going to try. (even though the third article did a pretty good job)

So, you kick a ball. What forces act on the ball? Well, the easy thing is to say “gravity and stuff that touches the ball”. In this case, the only thing the ball touches is the air. The air does indeed exert a force on the ball. The force the air exerts on the ball is ultimately due to collisions with the air particles and the ball. If the ball is spinning and non-smooth, there can be complex interactions. For this case, I will break this air force into two components.

- Air drag. If you have read this blog, you should be familiar with this model of air drag that says the force is proportional to the magnitude of the velocity squared and some other stuff (density of air, cross sectional area, and shape of the object).
- Magnus force. This is the force exerted on a moving and spinning object in a fluid or gas. Wikipedia’s page on the magnus effect is pretty ok.

There is also the gravitational force. But, let me just look at the ball from the top view. The key point of all of this is that if there were no spin effect or air drag, the ball would just move in a nice parabola. From the top, this would look like a straight and constant speed trajectory. If you exert a force perpendicular to the direction of motion, the ball will turn. If you exert a force in the opposite direction of the motion, the ball will slow down. These two things together make the ball do what it does.

Here is a force diagram of the ball as seen from the top (so you don’t see the gravitational force):

Why does this spinning cause a sideways force? Well, the idea is that the rough surface of the ball moves air near its surface. This means that on one side of the ball, the air is moving faster than the other side. On the faster moving air side, the air is moving more in a direction parallel to the motion of the ball. This means that an air particle is less likely to collide on the side of the ball and push it that way. The result is that there is more collisions on the slower side of the ball.

Here is the model that is commonly used for the air drag force:

Where the v-hat is a unit vector in the direction of the velocity of the ball. This along with the negative sign means that the air drag force is in the opposite direction as the velocity.

The magnus force can be written as:

S is some constant for the air resistance of the ball (a basketball and a soccer ball would have different values). The vector ω is the vector representing the angular velocity of the ball. For the diagram shown above, the vector ω would be perpendicular to the plane of the computer screen and coming out of the computer screen. The mangus force is related to the cross product of ω and the velocity. (here are some cross product tips).

Why don’t you always notice these forces? If the speed is slow and the mass is large, then the air drag and magnus forces will be small compared to the gravitational force. The motion for these cases will be dominated by the gravitational interaction. But with a high speed kick from a soccer ball (that has a relatively low mass) with a high angular spin, the effects can be noticed.

Let me model a high speed soccer ball in vpython. The original research paper gives some nice parameters that I will need for a soccer ball.

- Radius = 0.105 meters
- density = 74 times the density of air (if I understand the table correctly)
- S = 0.21 – I am pretty sure the S in this paper is the same S in the magnus force described above. – forget this S

After playing around (and finding that third article) I am pretty sure the S above is not the same S as in the wikipedia page. The physicsworld article gives the following useful info:

- Ball speed = 25-30 m/s
- angular velocity = 8 – 10 rev/sec
- Lift force (magnus force) of about 3.5 N
- horizontal ball deviation of about 4 meters
- ball mass of 410-450 grams (which agrees with my previous density)
- ball acceleration of about 8 m/s
^{2}– not sure if this is just the linear acceleration or the total magnitude of the acceleration and at the beginning or average?

If I assume the magnus force is S times the cross product of the angular and linear velocity, I can work backwards to find S (from the physicsworld data) in the case that the velocity and angular velocity are perpendicular.

Now for some python (here is my sloppy code –

magnus_force.py). I will make one assumption – the angular velocity of the ball is constant (which obviously will not be true).
6
Rhett Allain
<![CDATA[What the HECK is that? Number 3.]]>
http://scienceblogs.com/dotphysics/2010/09/03/what-the-heck-is-that-number-3/
2010-09-03T08:11:17Z
2010-09-03T08:11:17Z
Please note the official change of the title of this game, it is no longer “what is this”.
12
Rhett Allain
<![CDATA[Some Python notes]]>
http://scienceblogs.com/dotphysics/2010/09/02/some-python-notes/
2010-09-02T20:25:08Z
2010-09-02T20:25:08Z
Yes, I love python. However, I am no expert. Most of the stuff I write in python is dirty and ugly code. Sometimes I figure out new things (things that programmers already know) and sometimes I forget these things. So, here are a few tips and tricks that I use from time to time. Really, I am writing this for future Rhett when he does a google search for “how do you save data to a file in python”.
### Saving data to a file

### Functions

### Going through a list

### Histograms and Random Numbers

12
Rhett Allain
<![CDATA[Could I build a lightning detector?]]>
http://scienceblogs.com/dotphysics/2010/09/02/could-i-build-a-lightning-dete/
2010-09-02T11:50:54Z
2010-09-02T11:50:54Z
A while ago, we had a ton of lightning. As a bonus, it always happened in the middle of the night. I love sleeping where it sounds like I am on the front line in WWI – no, I don’t. But, while lying awake waiting for the next BOOM I thought of something. Instead of just counting the time between flash and boom, maybe I could make a lightning detector.
### Modeling Lightning

9
Rhett Allain
<![CDATA[Another look at evaluating teachers]]>
http://scienceblogs.com/dotphysics/2010/09/02/another-look-at-evaluating-tea/
2010-09-02T10:20:30Z
2010-09-02T10:20:30Z
The first thing that I saw was this article from nola.com (The Times-Picayune) “New teacher evaluation method being proposed in Jefferson Parish”. Let me summarize this article.
1

Here is what I get for the trajectory of the ball (as seen from above).

That is more than 4 meters deflection – but maybe they are assuming you aim to the left a little or something.

How about a plot of the total acceleration (magnitude) as a function of time.

This gives an acceleration of around 8 m/s^{2} around the end of the motion. Maybe this is what the physicsworld author meant. Oh well, that is enough for this. I know there is one problem. I assumed a constant coefficient of drag, but it seems that this might not be true.

Here is the item:

I suspect someone will know what this is. Honestly, I didn’t figure it out right away. However, I have found that the readers as a group generally are more knowledgeable than me by myself.

Oh, I don’t think there is really much description to add here. I included a meter stick for scale.

**P.S.** How come a device for measuring temperature is a thermometer and a device for measuring electric potential is a voltmeter? Shouldn’t the meterstick be called either a length-meter or a meter-meter? If you use the Queen’s English, I guess that would be metre-metre.

Suppose I am modeling a basketball falling through the air. I want to plot this data, so I save position and time data in lists. For example: Here is the info from scipy.org that covers this same stuff.

x = [0.1, 0.2, 0.3, 0.41, 0.52]

t=[1, 2, 3, 4, 5]

In this case, there really isn’t a problem. However, what if I have 1000 data points in each list and I want to use it again? If the program only takes a second to run, I will just re-create that data. Sometimes this is not feasible. What if I want to model throwing a basketball 1000 times and each time it takes about 1 second to calculate. 1000 seconds is not too long to wait, not too long unless you are impatient like me. Ok, how do you save this sucker as a file?

Here is a super-simple sample:

Of course, the key here is the “savetxt” function. If you don’t import the pylab module, it might not work. I think the savetxt function is part of numpy (which is in pylab) – just load pylab to be safe. Also, the file is saved to the same folder as your python script is in. The default settings for the savetxt function makes a space delimited file – you can change that if you want a comma delimiter, just add this:

One more note: Python is ruthlessly obedient. If you just spent 20 hours running a program and you save the file as temp_data.txt. Then later you run something and save it as temp_data.txt – done. It just overwrote your previous data. You can’t blame python, it is just doing what you told it to do.

What about getting the data back? Here is another sample that takes the data from the file created by the previous program and plots it.

The genfromtxt function basically is the inverse function of savetxt function. Notice that I had a list of lists for my data – I separated this into two separate lists for plotting (*gotta keep em separated*).

Everyone uses functions. But what if you want to make one yourself? It really isn’t too difficult. Let me start with a sample program. Suppose I want to use the same program as above, but I want to see what happens as I change the acceleration. One simple (and ugly) way would be to just keep copying the code from above how ever many times you want to change the acceleration. Another way would be to make a function that takes an acceleration and creates the data. Then you could just call this function as many times as you like.

Just to make this simple, suppose I want to look at the distance the object travels after 3 seconds as a function of acceleration.

Here, I created a function calc_dist(). It takes one parameter – the acceleration (which I labeled as ac so it wouldn’t get messed up with the variable a). The function is essentially the same as the previous program – but the key is the return. At the end of the function, what do you want it to give back? For this case, I have it just returning the final distance. It is possible to return any number of things. Suppose I wanted to also return the time (even though I already know that). At the end of the function, I would just put:

When I call this function, I could say result=calc(a), but result would be a list such that result[0] would be the position and result[1] would be the time.

The key thing to remember is to not make variables that appear both in the function and outside the function. This is bad. This is like crossing the streams from the Ghostbusters’ proton packs. Why are they called proton packs anyway?

I actually already used this idea above. What if I have a list of positions, and I want to print them:

The old Rhett would have made a variable n = 0 and then said something like “while n < 10:” and then in the loop have n = n +1. This python way is much easier. The ‘len’ is the length of the list and range says how high n should go. You don’t have to increment n yourself, python does it for you.

Oh, notice that I reference data[n][0]? Since data is a list of list – actually it looks like this:

The element data[3][0] would be the 4th in the list with the first element in that 4th thing – remember python starts with 0 being the first element.

Histograms are useful – and super easy to make with MatPlotLib (which is in the pylab module). Here is a sample program:

Here is the output from that program:

This really shows two useful functions:

- hist(): this is just like the plot function (and it is in pylab). Just pass the list of data to the function and it will make a histogram. Boom. That simple. If you like, you can tell it how many bins to make (in this case I said 10 – which happens to be the default). I also made the bars green (I don’t know why, but blue always shows up funny on the webpage). Also, I turned on the grid. This is the matplotlib documentation on histograms.
- nomralvariate(): This function produces a random number from the normal distribution. If I just used the “random()” function, the histogram would be boring and flat. The normalvariate function is not in pylab, so you have to load the random module. The main arguments it takes are the average and the standard deviation of the distribution you want. Here is a description of other functions in the random module.

Oh, and you are welcome future Rhett. I hope you still have at least a little bit of hair.

]]>For mere mortals, the first step might be to google “lightning detector”. I don’t want to do that. What fun would that be? I did look up something. The current in a typical lightning strike is on the order of 30,000 amps. How could I detect this.

I can think of two things. Could I detect the magnetic field from this current more than 10 miles away? Or maybe I could detect the change in magnetic flux through a loop of wire. For the second method it depends on the time rate of change of the magnetic field and the electric potential it would generate around a loop.

Let me pretend that lighting is a current that flows in a straight line (a huge wire in the sky). A single current creates magnetic fields that makes a circular vector field around the current. Here is a picture. (I will just use this lovely picture from wikipedia)

The magnitude of this magnetic field (for a long straight wire) changes with distance from the wire as:

Here μ_{0} is a constant and *r* is the distance from the “wire” to the location of interest. So, if I am 10 miles from a lightning strike, what kind of magnetic field could I even detect? This would be a magnetic field of 4 x 10^{-7} Tesla. Is that a large magnetic field? How about another example. What if I am 10 cm away from a wire with 1 amp of current? That would create a magnetic field of 2 x 10^{-6} Tesla. So, maybe it would be possible to detect this magnetic field (I will have to play with some detectors to try this).

The other question to address is time. How long does this current last? If it is super quick, I might not be able to even detect the magnetic field. This is directly tied to the other detection method – detecting an electric potential that goes with a changing magnetic field. I am not going to go into all the details (for now), but if you have a changing magnetic field and a loop of wire then the change in potential around that loop would be:

Here:

- N is the number of turns in the coil that makes up the loop
- B is the magnetic field vector
- n-hat is the unit vector that shows the orientation of the loop – it points perpendicular to the area of the loop
- A is the area of the loop

Suppose the area does not change. Also suppose that the magnetic field makes an angle θ with respect to the n-hat vector. This means that:

I honestly have no idea how long this lightning takes to happen. Also, this would give me the average change in electric potential – there are could be a spike depending on how quickly the magnetic field changes. Let me just suppose that Δt is around 0.1 seconds (just a guess) and my loop is a circle with a radius of 10 cm with 100 loops. What would the change in potential in the loop due to the lightning strike be? (assume best orientation of coil to lightning)

Ok, that is pretty low. Granted, my value for the change in time might be way off. But if it is not, even increasing the area and the number of loops both by a factor of 10 would still give a potential of around 10^{-3} volts.

There is another way to detect lightning – by the electromagnetic signal given off during the strike. If you google for “build a lightning detector”, you will find lots of info on these. Ok, but there is a problem. These all detect lightning, but I want to know where the lightning happens. I guess you could build two EM style lightning. If I want to know WHERE, I will need two detectors no matter which way I detect the lightning.

Enough rambling. I guess I should set up some small scale experiments.

]]>Basically, one of the local School Board wants to use a learning tool (Interval Testing) as a teacher evaluation tool. The Interval Testing program gives students spaced out evaluations through out the year to help them (and teachers) assess the preparedness of the students. These are non graded assessments and have been shown to help students. Note – the purpose of the implementation of Interval Testing is to increase student performance on standardized tests.

The school board’s idea is to then take those Interval Testing scores to determine the effectiveness of the teachers.

Is it just me? Or is this stuff getting out of control? If you turn these learning tools into evaluation tools, don’t you think the teachers will have more incentive to make sure the students score high (especially on later tests) rather than use them for learning? This is a bad idea.

Next – Chad at Uncertain Principles talks about another collection of teacher evaluation problems.

I think there are really two things going on here. First, like Chad says, evaluating teachers is a difficult task. Evaluators want some quantitative, non-subjective measurement tool (which doesn’t exist). Second, evaluating the teachers by looking at evaluations of students just seems like a plan for doomedness.

Instead of giving some insightful commentary on the whole issue, I will present what I think the people involved in this are thinking:

**Students:** We have more homework? Why? What about this standardized test at the end of the year? I only need a passing grade to move to the next grade-level, right? It doesn’t change my grades, right? Are we having spaghetti in the cafeteria?

**Teachers:** I can’t wait for this end of year testing to be over. That way we can cover some cool and interesting topics that will really get the students pumped up about science (or math, or history, or literature, or art…). Oh, these non-graded assessments to help students learn sure are working well. It’s great that they and I can see where their problems are.

**Evaluators of teachers:** (I put in this category principals and school board people and the like) How do we make sure these teachers are doing their job? There should be some number we can associate with each teacher to rate them. How about their height? That is a number. No wait, maybe that doesn’t make sense. Oh, what about about evaluating the teachers by evaluating the students. Students get grades – right? Just use that. Or height, I still like height. Tall teachers are good teachers, my momma used to say.

But why should it stop here? Shouldn’t the School Board be evaluated on how the teacher evaluations change? If they don’t show that teacher evaluations are increasing, they should get a poor evaluation.

Really this comes down to the same thing as my problem with grades. There are two things in education, learning and evaluation. If you aren’t careful and you mix the two up, bad stuff happens. So, am I saying that teachers should not be evaluated? Wouldn’t they just play minesweeper all day then? How can students learn if you don’t make them learn with a grade?

I propose that the principals and other evaluators just subjectively estimate the effectiveness of the teachers. School boards should trust the principals (I keep wanting to type principles – I blame Chad) to effectively evaluate the teachers.

]]>