Elastic Collisions - Page 1 by
alex nino and kirupa | 25 April 2010
When walking around London one day, I found a science
museum and decided to drop by and take a look inside.
Inside, I found this cool machine that has everything to do
with what this article is going to be about, elastic collisions. Anyway, I decided to take a
recording of it and you can see it below:
[ a real-life simulation of an elastic collision ]
When I saw that crazy machine, properly known as Energy
soda.co.uk, the first thing that came to my mind was
trying to emulate it in code. This article will provide an
overview of elastic collisions and examples of code where
you can see it in action.
With that said, this isn't a traditional article where I
provide some code and explain it line-by-line. Instead, the
goal is to provide increasingly complicated examples and the
associated source files so that you can explore how elastic
collisions can be used and implemented.
Some Optional Light Reading First
As you can guess, there is some level of physics knowledge
required to fully understand elastic collisions. While you
are not required to read the following articles, doing so
will bring some clarity to the madness that you are about to
be subjected to for the next two pages:
If you opted to not read the above articles, don't worry.
I will provide a very brief overview of the important
concepts that you need to know.
What are Elastic Collisions?
You probably know what a collision is. It is when objects
collide with each other. There are two parts to a collision.
The first part is the actual impact when two or more objects
hit each other. The second part is what happens after they
collide with each other. A collision where the total
of all objects before the first part is equal after the
total momentum in the second part is called an elastic
Notice that I am emphasizing momentum instead of energy.
The reason is that momentum only cares about speed because
the mass of the colliding objects isn't changing. When you
talk about energy, in reality with a collision, you will
lose some energy to heat, sound, and other things that will
subtract from the total energy left over for dealing with
Here is a
very simple example of elastic collision at work where you
have blocks of varying weight colliding with each other:
Notice the reaction after the collision between the
blocks. Some blocks bounce back faster than when they
initially collided. Some other blocks bounce back slower.
To reiterate, the main concept of elastic collisions is quite simple. An elastic
collision is a collision between two objects (bodies which
have mass) where the total momentum of the objects colliding
is preserved. In other words, none of the energy involved
in the collision is lost. It is distributed between the objects depending on their mass and speed they
when the collision happened.
Let's say you have two objects of different
masses moving towards each other:
They each have a certain speed before the collision. To
put another way, they have a certain momentum going into the
After the collision, the speed they have as they bounce back
will be something else:
How is that speed calculated? One thing we know is that
the total momentum the objects have before the collision
needs to be the same as the total momentum the objects have
after the collision. This is an ideal case where energy
isn't wasted on heat, sound, etc. Everything is purely
transferred into movement.
Well...this is where some
math comes into play. In the above diagram, I labeled the
mass and velocity (speed) of each block. The formula for
calculating the speed after a 2D collision is:
The variables u specify the speed of the
object before the collision. The variables v
specify the speed of the object after the collision.
Plugging in some values and converting the above formula
into code, you simply have:
mass1=3//mass of object A
vel1=-1//speed of object A (negative
because of collision, opposite direction against object