Chapter 1: Introduction to Bullet Collision Modeling

Whenever I come across something fascinating, I tend to show my appreciation by building a model. It's a ritual of mine. Recently, I was captivated by some impressive slow-motion footage of bullets colliding mid-air, featured by Smarter Every Day. It's definitely worth a watch.

In particular, I find the circular expansion of debris post-collision to be especially intriguing. The question arises: can I replicate this effect using basic physics and Python? For this project, I will be utilizing Web VPython, which offers convenient 3D objects for simulation.

This leads us to consider a straightforward scenario: the collision of two point particles approaching each other. How do we simulate the interaction between these two objects? Naturally, we will rely on fundamental physics principles.

Let's denote the two objects as A and B. When they collide, an interaction force arises between them. Notice that the force ( F_{B-A} ) is equal in magnitude but opposite in direction to ( F_{A-B} ), adhering to Newton's third law. A net force acting on an object results in a change in momentum, according to the momentum principle.

Since the forces are equal and opposite for the same duration, the momentum change of A will counterbalance the momentum change of B, indicating that total momentum remains conserved.

Now, how do we implement this in our model? One effective approach is to use springs. Imagine the two balls overlapping slightly. We can apply a force proportional to the extent of their overlap; if they don’t overlap, the force is zero—akin to "springy" balls.

The direction of the force is determined by the relative positions of balls A and B, making this model applicable to both glancing and direct collisions. To compute this force, we assume both balls have a radius ( R ), with vector positions ( r_A ) and ( r_B ). We will also introduce a spring constant ( k ) to quantify the force's magnitude.

The force expressions can be summarized as follows (assuming overlap exists):

# Pseudocode for force calculation

if overlap_exists:

force_A = -k * (2 * R - mag(r))

force_B = -force_A

The plan involves a numerical simulation where motion is divided into small time intervals. For each interval, we will:

1. Calculate the vector distance between A and B. If this distance is less than ( 2R ), we will assess for overlap and calculate the force.
2. Determine the forces acting on A and B (noting that they are equal and opposite).
3. Update the momentum for each ball using the momentum principle.
4. Adjust the positions of both balls based on their updated momentum.

Let's dive into the implementation in Python. Below is the code highlighting the essential parts.

# Initializing the balls

ballA = sphere(pos=vector(-0.03, 0, 0), radius=R, color=color.yellow)

ballB = sphere(pos=vector(0.03, 0, 0), radius=R, color=color.cyan)

# Setting initial conditions

v0 = 100 # initial velocity

k = 50000000 # spring constant

ballA.m = m

ballB.m = m

ballA.p = m * vector(v0, 0, 0)

ballB.p = m * vector(-v0, 0, 0)

Running this simulation reveals a straightforward interaction where the balls simply collide and bounce off each other. However, this doesn’t accurately reflect the complexity of high-speed bullet collisions.

Chapter 2: Advanced Bullet Collision Modeling

In the reality of high-speed bullet-bullet collisions, the bullets shatter into numerous small fragments. To effectively model this in Python, we can represent each bullet as a collection of tiny spheres. This way, when the bullets collide, all the tiny spheres can interact, potentially replicating the effect seen in the Smarter Every Day video.

Here's the plan for this enhanced simulation:

1. Divide each bullet into ( N ) smaller spheres.
2. Distribute these tiny spheres randomly within a spherical volume, simulating the original bullet's shape.
3. Allow all tiny spheres to interact during the collision.

To efficiently manage the many spheres, we will utilize lists in Python. Here’s a snippet of the code that constructs a single bullet from multiple smaller spheres.

# Constants for bullet creation

R = (11.5e-3) / 2 # radius of bullet

m = 0.012 # mass of bullet

N = 20 # number of small spheres

dm = m / N # mass of each small sphere

# List to hold the small spheres

bs = []

To ensure that the tiny spheres are properly positioned without overlapping, I will implement a function that checks for overlaps. If a new sphere overlaps with an existing one, it will be repositioned until it fits without collisions.

def overlap(rt, radi, rlist):

for rtemp in rlist:

rdist = rtemp.pos - rt

if mag(rdist) < 2 * radi:

return True

return False

We will then initiate a loop to create the spheres, ensuring they are placed in a suitable arrangement.

Following the setup, we can move to the simulation of the bullets approaching each other and eventually colliding.

# Bullet collision simulation

while t < .8e-3:

rate(200)

for b in bs:

b.F = vector(0, 0, 0) # Reset forces

# Calculate forces between spheres

for b in bs:

for a in bs:

rab = b.pos - a.pos

if mag(rab) < 2 * rpiece:

a.F += -k * (2 * rpiece - mag(rab)) * norm(rab)

This loop iterates over all spheres, calculating forces based on overlaps and updating their momentum and positions accordingly.

The results of this simulation reveal a more complex interaction. However, if the bullets collide off-axis, we can adjust the initial positions slightly to observe different collision dynamics.

To further refine our model, we can examine the conservation of momentum throughout the collision. Ideally, the system's total momentum should remain constant, and we can visualize this through a plot of momentum over time.