От какого крупнейшего и самого впечатляющего столкновения с астероидом нас может спасти Луна?

Что-то размером с импактор Чиксулуб было бы весьма впечатляющим - максимальный диапазон энергии его удара составляет пятьдесят тысяч гигатонн в тротиловом эквиваленте. Не было бы равного взрыва во всем человеческом существовании.

Основная проблема заключается в том, что для того, чтобы спасти человечество от удара, по определению любой импактор должен столкнуться с обратной стороной Луны. Выброс будет виден, как и движение самой Луны, но не момент удара.

Любой удар, достаточный для того, чтобы быть видимым с ближней стороны, т.е. Сила, направленная через всю Луну, возможно, уничтожив ее, вызовет у вас ту же проблему, с которой столкнулась человеческая раса в « Семиевах » Нила Стивенсона : сильный дождь .

Для большего удовольствия я адаптировал скрипт Python, который нашел здесь :

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[0]-x.position[0])**2) +
                             (self.position[1]-x.position[1])**2)
                gravityForce = G*(self.mass * x.mass)/((distance*gridScale)**2)

                x_pos = self.position[0] - x.position[0]
                y_pos = self.position[1] - x.position[1]

                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[0] + math.sin(math.radians(self.motionDirection))*traveled,
                             self.position[1] + math.cos(math.radians(self.motionDirection))*traveled)  # update pos
            data.append([self.position[0], self.position[1]])

            collision = 0
            for x in [y for y in Object._instances if y is not self]:
                if (self.position[0] - x.position[0])**2 + (self.position[1] - x.position[1])**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[0] for x in data], [x[1] 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)

Молот весит всего 10 Мкг, но его масса всегда будет иметь какое-то значение.

Я могу придумать, как можно было бы увидеть столкновение с Земли.

1 Возможно, удар создал бы облако из частиц пыли и испарившейся породы, которое расширилось бы до диаметра, в несколько раз превышающего диаметр Луны, и было бы освещено снизу раскаленной докрасна или более горячей лавой, образовавшейся в результате удара и хорошо видимой с Земли.

2 Возможно, астероид направляется прямо к Земле, но проходит близко к Луне, и лунная гравитация немного искривляет курс астероида в сторону Луны. Таким образом, астероид едва не промахивается мимо Земли, вращается вокруг нее и отбрасывается обратно к Луне. Астероид врезается в луну на ближней стороне в результате мощного взрыва. Астрономы подсчитали, что если бы астероид не столкнулся с Луной, он в конечном итоге упал бы обратно на Землю, вызвав вымирание.

Если вы используете одно из этих предложений, попробуйте рассчитать, возможно ли это с гравитационными силами и вероятным диапазоном скоростей астероидов.