# What's the biggest, most spectacular asteroid collision the moon could save us from?

An asteroid collision big enough and fast enough to see a massive ejection of rock and moon-chunks, from the surface of the earth AND not wipe out the population of the planet.

What size and speed of asteroid would it take to have a majorly visible and spectacular impact on the moon?

What after effects would this have? What would the moon look like? Would there be any minor effects in the earth?

• "The biggest" meaning the biggest collision between the Moon and a planetoid which would not destroy the humanity it its aftermath? – Alexander Feb 11 at 21:28
• @Alexander yes. – geekman Feb 11 at 21:32
• Welcome to Worldbuilding, geekman! If you have a moment, please take the tour and visit the help center to learn more about the site. You may also find Worldbuilding Meta and The Sandbox useful. Here is a meta post on the culture and style of Worldbuilding.SE, just to help you understand our scope and methods, and how we do things here. Have fun! – Gryphon Feb 11 at 21:39
• Your last question is ambiguous: you do not want the event to wipe out the population, but some 'damage' is allowed? – Jan Doggen Feb 11 at 21:56
• @Jan Doggen I figured somebody might bring up potential minor things, like changes to the tides or small mostly harmless meteorites. I'll edit the question though – geekman Feb 11 at 21:59

## 2 Answers

Something the size of the Chicxulub impactor would be plenty spectacular - the top range of its impact energy is fifty thousand gigatons of TNT equivalent. There wouldn't be an equivalent explosion in all of human existence.

The major problem is that in order to save humanity from an impact, by definition any impactor would have to hit the far side of the moon. The ejecta would be visible, as would the motion of the moon itself, but not the moment of impact.

Any impact sufficient to be visible on the near side - ie. force projected through the entire moon, possibly destroying it - will give you the same problem experienced by the human race in Neal Stephenson's Seveneves: a hard rain.

For added fun, I adapted a python script I found here:

import matplotlib.pyplot as plt
import math
plt.ion()

G = 6.673e-11  # gravitational constant
gridArea = [-20, 50, -20, 50]  # margins of the coordinate grid
gridScale = 10000000  # 1 unit of grid equals 10000000m or 10000km

plt.clf()  # clear plot area
plt.axis(gridArea)  # create new coordinate grid
plt.grid(b="on")  # place grid

class Object:
_instances = []
def __init__(self, name, position, radius, mass):
self.name = name
self.position = position
self.radius = radius  # in grid values
self.mass = mass
self.placeObject()
self.velocity = 0
Object._instances.append(self)

def placeObject(self):
drawObject = plt.Circle(self.position, radius=self.radius, fill=False, color="black")
plt.gca().add_patch(drawObject)
plt.show()

def giveMotion(self, deltaV, motionDirection, time):
if self.velocity != 0:
x_comp = math.sin(math.radians(self.motionDirection))*self.velocity
y_comp = math.cos(math.radians(self.motionDirection))*self.velocity
x_comp += math.sin(math.radians(motionDirection))*deltaV
y_comp += math.cos(math.radians(motionDirection))*deltaV
self.velocity = math.sqrt((x_comp**2)+(y_comp**2))

if x_comp > 0 and y_comp > 0:  # calculate degrees depending on the coordinate quadrant
self.motionDirection = math.degrees(math.asin(abs(x_comp)/self.velocity))  # update motion direction
elif x_comp > 0 and y_comp < 0:
self.motionDirection = math.degrees(math.asin(abs(y_comp)/self.velocity)) + 90
elif x_comp < 0 and y_comp < 0:
self.motionDirection = math.degrees(math.asin(abs(x_comp)/self.velocity)) + 180
else:
self.motionDirection = math.degrees(math.asin(abs(y_comp)/self.velocity)) + 270

else:
self.velocity = self.velocity + deltaV  # in m/s
self.motionDirection = motionDirection  # degrees
self.time = time  # in seconds
self.vectorUpdate()

def vectorUpdate(self):
self.placeObject()
data = []

for t in range(self.time):
motionForce = self.mass * self.velocity  # F = m * v
x_net = 0
y_net = 0
for x in [y for y in Object._instances if y is not self]:
distance = math.sqrt(((self.position-x.position)**2) +
(self.position-x.position)**2)
gravityForce = G*(self.mass * x.mass)/((distance*gridScale)**2)

x_pos = self.position - x.position
y_pos = self.position - x.position

if x_pos <= 0 and y_pos > 0:  # calculate degrees depending on the coordinate quadrant
gravityDirection = math.degrees(math.asin(abs(y_pos)/distance))+90

elif x_pos > 0 and y_pos >= 0:
gravityDirection = math.degrees(math.asin(abs(x_pos)/distance))+180

elif x_pos >= 0 and y_pos < 0:
gravityDirection = math.degrees(math.asin(abs(y_pos)/distance))+270

else:
gravityDirection = math.degrees(math.asin(abs(x_pos)/distance))

x_gF = gravityForce * math.sin(math.radians(gravityDirection))  # x component of vector
y_gF = gravityForce * math.cos(math.radians(gravityDirection))  # y component of vector

x_net += x_gF
y_net += y_gF

x_mF = motionForce * math.sin(math.radians(self.motionDirection))
y_mF = motionForce * math.cos(math.radians(self.motionDirection))
x_net += x_mF
y_net += y_mF
netForce = math.sqrt((x_net**2)+(y_net**2))

if x_net > 0 and y_net > 0:  # calculate degrees depending on the coordinate quadrant
self.motionDirection = math.degrees(math.asin(abs(x_net)/netForce))  # update motion direction
elif x_net > 0 and y_net < 0:
self.motionDirection = math.degrees(math.asin(abs(y_net)/netForce)) + 90
elif x_net < 0 and y_net < 0:
self.motionDirection = math.degrees(math.asin(abs(x_net)/netForce)) + 180
else:
self.motionDirection = math.degrees(math.asin(abs(y_net)/netForce)) + 270

self.velocity = netForce/self.mass  # update velocity
traveled = self.velocity/gridScale  # grid distance traveled per 1 sec
self.position = (self.position + math.sin(math.radians(self.motionDirection))*traveled,
self.position + math.cos(math.radians(self.motionDirection))*traveled)  # update pos
data.append([self.position, self.position])

collision = 0
for x in [y for y in Object._instances if y is not self]:
if (self.position - x.position)**2 + (self.position - x.position)**2 <= x.radius**2:
collision = 1
impactor = self.name
impactee = x.name
velocity = self.velocity
break
if collision != 0:
print("Collision! %s struck %s at %d m/s" % (impactor, impactee, velocity))
break

plt.plot([x for x in data], [x for x in data])

Earth = Object(name="Earth", position=(0.0, 25.0), radius=0.6371, mass=5.972e24)
Moon = Object(name="Moon", position=(38.45, 25.0), radius=0.1737, mass = 7.347e22)  # The orbital distance of the moon is ~ 384.5 thousand km.
Hammer = Object(name="Hammer", position=(38.80, 25.20), radius=0.0001, mass=1.0e10)

Hammer.giveMotion(deltaV=2000.0, motionDirection=270, time=100000)
plt.show(block=True)


The Hammer is just 10Mkg, but its mass is always going to be somewhat irrelevant.

• Actually, if the impact is big enough that you can see the Moon move, you're at risk for secondary effects such as "turning the Moon into a planetary ring". – Mark Feb 11 at 22:12
• Well, for a given value of "see". There are lots of observatories that routinely bounce lasers off the moon to measure distance. If an impact kicked it closer by a few kilometers, people would notice. It just wouldn't be a naked eye thing. – jdunlop Feb 11 at 22:29
• I disagree that it would have to be the "far" side of the Moon. The Moon's gravity could deflect the course of the incoming object so that it impacted the Moon on the near side. Granted, it would have to be a small deflection, and the impact would be a VERY glancing blow to the moon, and it would be VERY near the dividing line between the near and far sides of the Moon. But I think that all of those aspects would lead to MUCH more spectacular visuals than a direct 'head on' impact. (though it would likely also increase damage to Earth, as most debris would be directed roughly toward Earth) – Dalila Feb 12 at 16:15
• @Dalila - that's actually physically impossible. If the object is travelling slowly enough that it deflects sufficiently to impact the moon, it would still impact the far side. Given nothing but gravitation, not only can it not curve back on itself, but past the moon the Earth's gravitational field will tip the balance. – jdunlop Feb 12 at 22:07
• The Moon deflects it an then somehow, the next time it crosses Earth orbit while Earth is there, it impacts the near side. Absurdly improbable, but technically possible. – Eth Feb 13 at 10:18

I can think of ways the impact could be visible from Earth.

1 Possibly the impact would create a cloud of dust particles and vaporized rock that would expand to several times the diameter of the moon and be lit from below by red hot or hotter lava created by the impact and easily visible from Earth

2 Possibly the asteroid is headed directly for Earth but passes close to the Moon and the lunar gravity bends the course of the asteroid toward the moon a little. The asteroid thus barely misses the Earth and whips around it and is slung back toward the Moon. The asteroid hits the moon on the near side in a tremendous explosion. And astronomers calculate that if the asteroid hadn't hit the Moon it would eventually have fallnd back on Earth causing an extinction event.

If you use one of those suggestions try to calculate if it is possible with the gravitional forces and the probable asteroid velocity range.

• On the first count, I don't think it'd need to be lit from below by lava - ejecta would be lit by the sun, and therefore be more than visible enough. – jdunlop Feb 12 at 21:48