¿Cuál es la colisión de asteroides más grande y espectacular de la que la Luna podría salvarnos?

Una colisión de asteroides lo suficientemente grande y rápida como para ver una eyección masiva de rocas y trozos de luna desde la superficie de la tierra Y no acabar con la población del planeta.

¿Qué tamaño y velocidad de asteroide se necesitaría para tener un impacto mayormente visible y espectacular en la luna?

¿Qué efectos secundarios tendría esto? ¿Cómo sería la luna? ¿Habría algún efecto menor en la tierra?

¿"El más grande" significa la colisión más grande entre la Luna y un planetoide que no destruiría a la humanidad después?
@Alejandro sí.
¡Bienvenido a Worldbuilding, friki! Si tiene un momento, realice el recorrido y visite el centro de ayuda para obtener más información sobre el sitio. También puede encontrar Worldbuilding Meta y The Sandbox útiles. Aquí hay una meta publicación sobre la cultura y el estilo de Worldbuilding.SE, solo para ayudarlo a comprender nuestro alcance y métodos, y cómo hacemos las cosas aquí. ¡Divertirse!
Su última pregunta es ambigua: ¿no quiere que el evento elimine a la población , pero se permite algún 'daño'?
@Jan Doggen Pensé que alguien podría mencionar posibles cosas menores, como cambios en las mareas o pequeños meteoritos en su mayoría inofensivos. Aunque editaré la pregunta
El ángulo de impacto también es un factor significativo, además del tamaño y la velocidad. Si está buscando un efecto tipo nube de hongo/explosión, querrá un impacto directo y frontal, y eso tendría que ser relativamente grande/rápido. Pero un golpe oblicuo de un objeto mucho más pequeño podría envolver un anillo de escombros alrededor de la luna, algunos de los cuales volverían a impactar en la luna durante mucho tiempo, creando un conjunto completamente nuevo de efectos. Pero si es demasiado grande, el golpe oblicuo podría enviar esos escombros hacia la Tierra con consecuencias devastadoras...
¿Tiene que ser un asteroide que habría golpeado la tierra si la luna no hubiera estado allí? ¿O solo tiene que ser un golpe de luna espectacular?

Respuestas (2)

Algo del tamaño del impactador Chicxulub sería bastante espectacular: el rango superior de su energía de impacto es de cincuenta mil gigatoneladas de TNT equivalente. No habría una explosión equivalente en toda la existencia humana.

El principal problema es que para salvar a la humanidad de un impacto, por definición, cualquier impactador tendría que impactar en el otro lado de la luna. La eyección sería visible, al igual que el movimiento de la luna misma, pero no el momento del impacto.

Cualquier impacto suficiente para ser visible en el lado cercano , es decir. fuerza proyectada a través de toda la luna, posiblemente destruyéndola, le dará el mismo problema experimentado por la raza humana en Seveneves de Neal Stephenson : una lluvia fuerte .

Para mayor diversión, adapté un script de python que encontré aquí :

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)

El Martillo pesa solo 10Mkg, pero su masa siempre será algo irrelevante.

En realidad, si el impacto es lo suficientemente grande como para que puedas ver el movimiento de la Luna, corres el riesgo de sufrir efectos secundarios como "convertir la Luna en un anillo planetario".
Bueno, para un valor dado de "ver". Hay muchos observatorios que rutinariamente hacen rebotar láseres en la luna para medir la distancia. Si un impacto lo acercara unos pocos kilómetros, la gente lo notaría. Simplemente no sería una cosa a simple vista.
No estoy de acuerdo en que tendría que ser el lado "lejano" de la Luna. La gravedad de la Luna podría desviar el curso del objeto entrante para que impactara la Luna en el lado cercano. De acuerdo, tendría que ser una pequeña desviación, y el impacto sería un golpe MUY oblicuo a la luna, y estaría MUY cerca de la línea divisoria entre los lados cercano y lejano de la Luna. Pero creo que todos esos aspectos conducirían a efectos visuales MUCHO más espectaculares que un impacto directo 'de frente'. (aunque probablemente también aumentaría el daño a la Tierra, ya que la mayoría de los desechos se dirigirían aproximadamente hacia la Tierra)
@Dalila: eso es físicamente imposible. Si el objeto viaja lo suficientemente lento como para desviarse lo suficiente como para impactar en la luna, aún impactaría en el lado opuesto. Dado nada más que la gravitación, no solo no puede curvarse sobre sí mismo, sino que más allá de la luna, el campo gravitatorio de la Tierra inclinará la balanza.
La Luna lo desvía y luego, de alguna manera, la próxima vez que cruza la órbita de la Tierra mientras la Tierra está allí, impacta en el lado cercano. Absurdamente improbable, pero técnicamente posible.

Puedo pensar en formas en que el impacto podría ser visible desde la Tierra.

1 Posiblemente el impacto crearía una nube de partículas de polvo y roca vaporizada que se expandiría varias veces el diámetro de la luna y sería iluminada desde abajo por lava al rojo vivo o más caliente creada por el impacto y fácilmente visible desde la Tierra

2 Posiblemente el asteroide se dirige directamente hacia la Tierra pero pasa cerca de la Luna y la gravedad lunar desvía un poco el curso del asteroide hacia la Luna. Por lo tanto, el asteroide apenas pasa por alto la Tierra, gira alrededor de ella y se lanza hacia la Luna. El asteroide golpea la luna en el lado cercano en una tremenda explosión. Y los astrónomos calculan que si el asteroide no hubiera golpeado la Luna, eventualmente habría vuelto a caer a la Tierra causando un evento de extinción.

Si usa una de esas sugerencias, intente calcular si es posible con las fuerzas gravitacionales y el rango probable de velocidad del asteroide.

En primer lugar, no creo que sea necesario iluminarlo desde abajo con lava; la eyección sería iluminada por el sol y, por lo tanto, sería más que visible.
¿Cuál es la colisión de asteroides más grande y espectacular de la que la Luna podría salvarnos?
RespuestasAquíPolítica de privacidad1y, 0v