Was ist die größte und spektakulärste Asteroidenkollision, vor der uns der Mond retten könnte?

Eine Asteroidenkollision, die groß genug und schnell genug ist, um einen massiven Auswurf von Steinen und Mondbrocken von der Erdoberfläche zu sehen UND nicht die Bevölkerung des Planeten auszulöschen.

Welche Größe und Geschwindigkeit eines Asteroiden wäre nötig, um einen weithin sichtbaren und spektakulären Einschlag auf dem Mond zu haben?

Welche Nachwirkungen hätte das? Wie würde der Mond aussehen? Würde es geringfügige Auswirkungen auf die Erde geben?

"Die Größte" bedeutet die größte Kollision zwischen dem Mond und einem Planetoiden, die die Menschheit nicht in ihren Nachwirkungen zerstören würde?
@ Alexander ja.
Willkommen bei Worldbuilding, Geekman! Wenn Sie einen Moment Zeit haben, nehmen Sie bitte an der Tour teil und besuchen Sie das Hilfezentrum , um mehr über die Website zu erfahren. Sie können auch Worldbuilding Meta und The Sandbox nützlich finden. Hier ist ein Meta-Beitrag über die Kultur und den Stil von Worldbuilding.SE, nur um Ihnen zu helfen, unseren Umfang und unsere Methoden zu verstehen und wie wir die Dinge hier tun. Spaß haben!
Ihre letzte Frage ist zweideutig: Sie wollen nicht, dass die Veranstaltung die Bevölkerung auslöscht , aber ein gewisser „Schaden“ ist erlaubt?
@Jan Doggen Ich dachte, jemand könnte potenzielle Kleinigkeiten ansprechen, wie Änderungen der Gezeiten oder kleine, meist harmlose Meteoriten. Ich werde die Frage aber bearbeiten
Neben Größe und Geschwindigkeit ist auch der Aufprallwinkel ein wesentlicher Faktor. Wenn Sie nach einem Pilzwolken- / Explosionseffekt suchen, möchten Sie einen direkten und frontalen Aufprall, und dieser müsste relativ groß / schnell sein. Aber ein flüchtiger Schlag von einem viel kleineren Objekt könnte einen Ring aus Trümmern um den Mond wickeln, von denen einige den Mond für lange Zeit erneut treffen und eine ganze Reihe neuer Effekte erzeugen. Aber wenn es zu groß ist, könnte der Streifschuss diese Trümmer mit verheerenden Folgen zur Erde schleudern ...
Muss es ein Asteroid sein, der die Erde getroffen hätte, wenn der Mond nicht da gewesen wäre? Oder muss es einfach nur ein spektakulärer Mondschlag sein?

Antworten (2)

Etwas von der Größe des Chicxulub-Impaktors wäre ziemlich spektakulär – der Spitzenbereich seiner Aufprallenergie beträgt fünfzigtausend Gigatonnen TNT-Äquivalent. Es würde keine vergleichbare Explosion in der gesamten menschlichen Existenz geben.

Das Hauptproblem besteht darin, dass, um die Menschheit vor einem Aufprall zu retten , jeder Impaktor per Definition auf die andere Seite des Mondes treffen müsste . Der Auswurf wäre sichtbar, ebenso wie die Bewegung des Mondes selbst, aber nicht der Moment des Aufpralls.

Jeder Aufprall, der ausreicht, um auf der nahen Seite sichtbar zu sein – d.h. Kraft, die durch den gesamten Mond projiziert wird und ihn möglicherweise zerstört - wird Ihnen das gleiche Problem bereiten, das die menschliche Rasse in Neal Stephensons Seveneves erlebt hat : ein starker Regen .

Für zusätzlichen Spaß habe ich ein Python-Skript angepasst, das ich hier gefunden habe :

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)

Der Hammer wiegt nur 10 Mkg, aber seine Masse wird immer etwas irrelevant sein.

Wenn der Aufprall groß genug ist, dass Sie sehen können, wie sich der Mond bewegt, besteht die Gefahr von Sekundäreffekten wie "den Mond in einen Planetenring verwandeln".
Nun, für einen bestimmten Wert von "see". Es gibt viele Observatorien, die routinemäßig Laser vom Mond abprallen lassen, um die Entfernung zu messen. Wenn ein Aufprall es um ein paar Kilometer näher rückte, würden die Leute es bemerken. Es wäre einfach keine Sache mit bloßem Auge.
Ich bin anderer Meinung, dass es die "ferne" Seite des Mondes sein müsste. Die Schwerkraft des Mondes könnte den Kurs des ankommenden Objekts ablenken, so dass es auf der nahen Seite auf den Mond aufprallte. Zugegeben, es müsste eine kleine Ablenkung sein, und der Aufprall wäre ein SEHR flüchtiger Schlag auf den Mond, und er wäre SEHR nahe an der Trennlinie zwischen der nahen und der fernen Seite des Mondes. Aber ich denke, dass all diese Aspekte zu VIEL spektakuläreren visuellen Effekten führen würden als ein direkter Aufprall. (obwohl es wahrscheinlich auch den Schaden an der Erde erhöhen würde, da die meisten Trümmer ungefähr auf die Erde gerichtet wären)
@Dalila - das ist eigentlich physikalisch unmöglich. Wenn sich das Objekt langsam genug bewegt, dass es ausreichend abgelenkt wird, um auf den Mond aufzuprallen, würde es immer noch auf der anderen Seite auftreffen. Wenn nichts als die Gravitation gegeben ist, kann es nicht nur nicht auf sich selbst zurückkrümmen, sondern das Gravitationsfeld der Erde wird am Mond vorbei das Gleichgewicht kippen.
Der Mond lenkt ihn dann irgendwie ab, wenn er das nächste Mal die Erdumlaufbahn kreuzt, während die Erde dort ist, schlägt er auf der nahen Seite auf. Absurd unwahrscheinlich, aber technisch möglich.

Ich kann mir vorstellen, wie der Einschlag von der Erde aus sichtbar sein könnte.

1 Möglicherweise würde der Aufprall eine Wolke aus Staubpartikeln und verdampftem Gestein erzeugen, die sich auf den mehrfachen Durchmesser des Mondes ausdehnt und von unten durch glühende oder heißere Lava beleuchtet wird, die durch den Aufprall entstanden und von der Erde aus gut sichtbar ist

2 Möglicherweise steuert der Asteroid direkt auf die Erde zu, passiert aber nahe am Mond vorbei und die Schwerkraft des Mondes biegt den Kurs des Asteroiden ein wenig in Richtung Mond. Der Asteroid verfehlt daher nur knapp die Erde, wirbelt um sie herum und wird zurück zum Mond geschleudert. Der Asteroid trifft den Mond auf der nahen Seite in einer gewaltigen Explosion. Und Astronomen berechnen, dass der Asteroid, wenn er den Mond nicht getroffen hätte, schließlich auf die Erde zurückgefallen wäre und ein Aussterben verursacht hätte.

Wenn Sie einen dieser Vorschläge verwenden, versuchen Sie zu berechnen, ob es mit den Gravitationskräften und dem wahrscheinlichen Asteroidengeschwindigkeitsbereich möglich ist.

Erstens glaube ich nicht, dass es von unten durch Lava beleuchtet werden müsste - Auswurf würde von der Sonne beleuchtet und wäre daher mehr als sichtbar genug.
Was ist die größte und spektakulärste Asteroidenkollision, vor der uns der Mond retten könnte?
AntwortenHierDatenschutz-Bestimmungen1y, 0v