A friend of mine was telling me that when you play rugby, you can count on the ball bouncing up nice and high for you every third bounce. He showed me in the gym how that’s basically true and I’ve been wondering about it ever since. This post is one way I was thinking of modeling it.
For this first pass, I thought I’d look at a bouncing ellipse (in 2D). I figured it would sometimes bounce low (and spin fast) and sometimes high (and spin slow). I thought I could look to see if it “bounces high” in any particular pattern.
Here’s an animation of what I did:
You can see that the height of the bounce does change. Here’s a plot of the height of the center as a function of time:
There’s definitely some variability, but not as much as you can see in some rugby matches:
Here’s a plot showing several height plots for several different initial orientations
It’s clear that there can be quite a bit of variability of heights. Here’s an animation showing that:
So I don’t think this really shows a “every third bounce” pattern, but I think it’s a good start.
How I did it
I tried three different approaches to get these calculations. Only the last one worked, but I learned a lot.
First I thought I’d use the new support in Mathematica for regions. You can define a region (the ellipse) and the region for the ground (half plane) and then look for the intersection to see if they’ve hit each other. Then you can calculate the area of the intersection to use in calculating a potential energy. Good in principle, but super slow and the derivatives needed to do on the potential energy didn’t work. Oh well.
Next I thought I’d try to learn how to use the new mesh/Finite Element procedures. I thought I could find the best triangular mesh for the ellipse and treat all the lines between nodes as springs. Here’s the (very slow!) result:
As you can see, the “ball” gets severely distorted upon the bounce. Also, I think treating all the mesh lines as springs doesn’t correctly represent the stiffness of the internal structure of the ball.
Finally I just decided to say that the ground was a giant one-way spring (it only pushes, it doesn’t pull) and then identify when (and where) the ellipse pokes into the ground. It took me a while to figure out the lowest point of an ellipse, but it was really just differentiating the parametric equation to find a minimum in y. So then I could say that my potential energy is just proportional to y^2 where y is the distance that the lowest point gets below the ground plane. That’s the form of a spring and lets the ground push the ellipse back up. In my experience, this is a useful way to do bounces because it tends to conserve energy and correctly model the time it takes to collide.
What’s cool about doing it using a Lagrange approach (with a potential energy) is that I don’t have to do things like “when it hits, reverse the momentum” and “when it hits, figure out the impulse torque to figure out the change to angular momentum.” Instead I just put the potential energy in as a function of y and theta and the Euler-Lagrange equation takes care of all the rest. Specifically it gets the angular momentum just right without every calculating an impulse torque.
So, the upshot is, I think that high bounces are possible using this mechanism, though a predictable “once every three bounces” doesn’t seem to be happening. This was fun modeling though, and I look forward to adding other approaches based on your comments below (hint hint).
Your thoughts? Here are some starters for you:
- I’m in this class and, wait, never mind, it’s summer
- I think this is cool, but I think you can make it better by . . .
- I think this is dumb, what you forgot about was . . .
- Why don’t you add friction?
- Why don’t you add some x velocity?
- Here’s a better way to deal with that mesh . . .
- Mathematica does Finite Element Analysis now? Cool, can it do . . .
- What is Finite Element analysis?
- Why was finding the bottom of the ellipse so hard? Seems easy to me!
- Please let me know when you redo this in Python, then I’ll read it.