Monitoring in Echtzeit: Der Zugang zu Seismogrammen und Erdbebenkatalogen

Schwärme, Serien und starke Erdbeben im grenznahen Ausland: Deutschland erlebte in den letzten acht Wochen die wohl seismisch aktivste Phase seit vielen Jahren. Viele Menschen, die wegen eigener Betroffenheit oder nur aus Interesse die Aktivität verfolgen, haben bei uns in den vergangenen Wochen angefragt, wie man als Privatperson auf die Daten von Erdbebenstationen zugreifen kann, um die Situation vor der eigenen Haustür in Echtzeit verfolgen zu können. Darum möchte ich in folgender Anleitung erklären, wie jeder, der einen Computer besitzt, mit kostenloser Open Source Software an diese Daten kommt. Auch der Zugriff auf Kataloge früherer Erdbeben ist möglich und für jede Region individuell anpassbar. Direkt zu Beginn die Warnung: Es ist nicht kinderleicht und erfordert auch ein wenig Vorbereitung. Allein die Installation kann, je nach Programmierkenntnissen, bis zu 30 Minuten in Anspruch nehmen. Zudem könnten alte Rechner unter Umständen Schwierigkeiten bekommen. Aber die Mühe lohnt sich.

Inhaltsverzeichnis:

  1. Vorbereitung und Installation
  2. Zugriff auf Seismogramme, Echtzeit- und Archivdaten sowie Nutzbarkeit
  3. Zugriff auf Erdbebenkataloge und Abfrage früherer Erdbeben in einer Region

Seismologische Daten sind zu Forschungszwecken von vielen Erdbebendiensten und staatlichen Behörden zur öffentlichen Nutzung freigegeben. Gerade bei Erdbeben, die oft nicht nur regional beschränkt sind, ist diese globale Vernetzung extrem wichtig. Doch nicht nur Seismologen und andere Forscher können auf diese Daten zugreifen.

In diesem Text möchte ich euch mit dem Seismologie-Tool Obspy vertraut machen. Obspy ist ein Open Source Tool, das sich der Programmiersprache Python bedient und extra zum Zwecke seismologischer Auswertungen entwickelt wurde. Mit Obspy kann man auf Seismogramme zugreifen, diese auswerten, Erdbebenkataloge abfragen und, wer sich tiefer mit der Materie beschäftigen will, sogar Erdbeben lokalisieren. Zusammen mit anderen kostenlosen Modulen sind der Kreativität eigentlich keine Grenzen gesetzt. Das Spektrum der Optionen reicht von der Umwandlung von Erdbebendaten in MP3-Dateien bis hin zur Erstellung von Tsunami-Animationen.

Um in diese Wunderwelt einzutauchen, ist es erstmal nötig, Python auf dem eigenen Rechner zu installieren. Je nach Betriebssystem ist dies unterschiedlich kompliziert. Auf Linux ist Python meist schon verfügbar. Windows-Nutzer müssen etwas mehr Arbeit investieren. Da ich selbst Windows nutze, werde ich mich auf diese Anleitung beschränken. Andere Nutzer können den Anleitungen auf den jeweils verlinkten Websites folgen.

Ein umfangreiches Software-Bundle zur Nutzung von Python ist Anaconda. Mit Anaconda wird nicht nur die Umgebung für Python installiert, sondern auch mehrere Programme, welche die vereinfachte Arbeit mit Python ermöglichen. Es gibt noch andere Tools, zum Beispiel WinPython, aber im Folgenden beschränke ich mich auf Anaconda, da ich selbst damit sehr zufrieden bin.

Zunächst muss Anaconda für Windows von dieser Seite heruntergeladen werden. Danach folgt bitte der beschriebenen Installationsanleitung. Der Installationsprozess ist nicht groß anders als bei beliebigen anderen Windows-Anwendungen. Jedoch ist das Anaconda-Bundle relativ groß (mehrere GB), sodass das ganze einige Zeit dauert.

Nach der Installation findet ihr auf eurem Rechner die Anwendung „Anaconda Navigator“. Diesen müsst ihr starten, um die weiteren Installationsprozesse durchzuführen. Folgender Bildschirm müsste erscheinen.

Ihr seht eine Übersicht der mit Anaconda verfügbaren Programme, die aber (anders als in meinem Screenshot) bei euch noch nicht installiert sind. Diese haben verschiedene Funktionen und ermöglichen die Arbeit mit Python. Für unsere Zwecke ist zunächst nur das Programm „Spyder“ relevant. Aber bevor ihr mit Spyder weitermachen könnt, müsst ihr zunächst eine eigene „Environment“ einrichten, also eine lokale Arbeitsumgebung, in der eure Python-Programme später laufen sollen. Dazu klickt im Navigator-Startbildschirm links auf „Environments“.

Zunächst seid ihr in der Basis-Environment, genannt „base (root)“. Alle verfügbaren Environments findet ihr in der zweiten Spalte von links. Im Screenshot von mir ist neben der base-Environment auch schon die eigene namens „obspy“ angezeigt. Bei euch sollte nur die base-Environment angezeigt werden. Rechts seht ihr die Übersicht der Tools, die von Anaconda vorinstalliert sind. Obspy gehört nicht dazu.
Als nächstes erstellt ihr euch eure eigene Environment, indem ihr unten links auf „Create“ klickt. Es erscheint ein Fenster, in dem ihr den Namen der Environment und die Python-Version frei wählen könnt. Ich habe in dem Beispiel die Environment „Erdbebennews“ genannt. Meine Programme laufen alle noch auf der Version 3.7. Ihr könnt aber auch die aktuellste Version 3.8 wählen.
Nachdem ihr euch einen Namen ausgesucht und die Version gewählt habt, klickt auf „Create“. Anaconda richtet euch nun eine neue Environment ein. Dies kann einige Minuten dauern.

Nach erfolgreicher Einrichtung seht ihr eure neue Environment. Die Auswahl der dort installierten Module ist äußerst überschaubar.

Viel kann man (zumindest ausgehend von unseren Absichten) mit den Tools nicht machen. Darum müssen jetzt manuell alle wichtigen Module installiert werden. Klickt dazu in der zweiten Spalte von links auf den grünen Pfeil rechts neben dem Namen eurer Environment und wählt „Open Terminal“. Es öffnet sich folgendes Fenster, wo ihr links oben den Namen eurer Environment seht.

Mit diesem Befehlsfenster könnt ihr nun manuell alle nötigen Installationen und Modifikationen vornehmen. Ab hier arbeitet ihr in der Programmiersprache Python. Vorkenntnisse sind allerdings nicht notwendig. Ihr könnt im folgenden einfach weiter alle Schritte befolgen. Solltet ihr später selbst mit Python arbeiten wollen, findet ihr online unendlich viele Schritt-Für-Schritt-Anleitungen für alle möglichen Projekte, die einen sehr guten Einstieg bieten.

Für unser Projekt müsst ihr zunächst Obspy installieren Dazu schreibt ihr folgende Zeile in das Fenster und klickt auf Enter:

pip install obspy
(Weitere Informationen zu Obspy)

Das Programm bezieht nun automatisch Obspy vom Server und installiert es. Praktischerweise werden auch alle anderen Tools wie Numpy und Matplotlib, die für Obspy essentiell sind, mit installiert. Wenn die Installation abgeschlossen ist, seht ihr unter den Namen der installierten Module wieder den Namen eurer Environment, sodass ihr neue Befehle eingeben könnt.

Wenn es nur darum geht, Erdbebendaten und Seismogramme zu beziehen, ist nun alles notwendige installiert. Da ich euch aber auch ein paar Möglichkeiten der Anwendung zeigen möchte, benötigen wir noch ein paar andere Module. Darum führt nun bitte noch beide folgenden Befehle aus, um entsprechende Module zu installieren.

pip install pandas
(Weitere Informationen zu Pandas)
conda install -c conda-forge cartopy
(Weitere Informationen zu Cartopy)

Für letzteres sind etwas mehr als 200 MB Speicher notwendig.

Nun könnt ihr das Befehlsfenster schließen und zum Anaconda Navigator zurückkehren. Dort wechselt ihr vom „Environment“-Fenster zurück ins „Home“-Fenster. Stellt sicher, dass oben bei „Applications on…“ eure selbst erstellte Environment ausgewählt ist. Dann könnt ihr bei Spyder auf „Install“ klicken und auch dieses Programm installieren. Dies dauert erneut eine Minute. Wenn die Installation abgeschlossen ist, öffnet Spyder, indem ihr auf „Launch“ klickt.

Sobald Spyder läuft, sind alle Vorbereitungen abgeschlossen. Das Standard-Layout von Spyder besteht aus drei Fenstern: Eurem Code links, der Konsole unten rechts und dem Objekt-Fenster oben rechts. Im Code-Fenster schreibt ihr später eure Programme, um beispielsweise Erdbebendaten abzurufen. Ein Programm besteht in der Regel aus mehreren Zeilen, während ihr unten in der Konsole einzelne Befehle, zum Beispiel die Darstellung von Variablen, ausführen könnt. Zudem fungiert die Konsole als Informationsfeld für euch. Fehlermeldungen und vergangene Befehle („History“) werden dort angezeigt.
Das Objekt-Fenster ist nochmals unterteilt in die Bereiche „Help“, „Variable Explorer“, „Plots“ und „Files“, je nachdem, welchen Reiter ihr wählt. „Help“ ist, wie der Name schon sagt, ein Hilfebereich, wo ihr Tipps und Anleitungen findet. „Variable Explorer“ wird wichtig, wenn ihr längere Codes schreibt, denn dort werden die Variablen, Datentypen und Werte aufgelistet. Für dieses Tutorial ist das aber erstmal nicht relevant. Bei „Plots“ werden Grafiken und Karten, zum Beispiel Seismogramme, angezeigt, die ihr mit eurem Code erstellt. „Files“ bietet eine Übersicht über die in der aktuellen Ordnerstuktur verfügbaren Dateien.

Spyder lässt sich optisch anpassen. Für weitere Informationen zu dem Programm, könnt ihr auf der Website von Spyder alle wichtigen Informationen finden. Hier geht es aber nun weiter mit den Seismogrammen.

2. Zugriff auf Seismogramme, Echtzeit- und Archivdaten sowie Nutzbarkeit

Wie eingangs erwähnt, stellen viele Erdbebendienste ihre Aufzeichnungen und Kataloge der Öffentlichkeit zur Verfügung. Dies geschieht in der Regel über sogenannte FDSN-Web-Services.
Um an die Daten zu kommen, müsst ihr aber natürlich erstmal wissen, welche Daten überhaupt verfügbar sind. Dazu braucht es nämlich zunächst eine seismologische Station, die Daten aufzeichnet. Weltweit gibt es mehrere zehntausend Stationen mit öffentlichen Daten. Folgende Beispiele beschränken sich erstmal nur auf Deutschland.

Hierzulande gibt es drei Erdbebendienste, die die Daten ihrer Netzwerke über FDSN zur Verfügung stellen: Das Geoforschunszentrum Potsdam (GFZ), die Bundesanstalt für Geowissenschaften und Rohstoffe (BGR) und der Erdbebendienst der Universität München (LMU). Aber auch der Schweizerische Erdbebendienst (SED) hat mehrere Stationen in Deutschland.
Die einzelnen Stationen eines Betreibers, im Folgenden „Client“ genannt, sind nochmals in verschiedene seismologische Netzwerke unterteilt. Während das GFZ in Deutschland über das GE-Netz verfügt, wird das landesweite Netz der BGR mit GR abgekürzt. Zudem gibt es mehrere lokale Netze in Sachsen (SX), Thüringen (TH) und in Nordrhein-Westfalen (RN). Das Bayern-Netz der LMU trägt das Kürzel BW.

Ein weiteres Netz, das über zahlreiche Stationen in Deutschland verfügt, ist das Raspberry-Netz (AM). Dazu aber am Ende dieses Kapitels mehr.

Auf der FDSN-Webseite findet ihr eine Übersicht aller aktuellen und früheren Netzwerke sowie die zu diesem Netzwerk gehörenden Stationen.

Nun kommen wir zu Spyder und die Arbeit mit Obspy. Ich werde euch die grundlegenden Befehle sowie Erklärungen dazu hier geben. Ihr könnt aber auch das äußerst umfangreiche Tutorial auf der Obspy-Homepage nutzen. Dort findet ihr noch viele weitere Funktionen und Optionen.

Ihr könnt nun Spyder nutzen, um auf die Funktionen von Obspy zuzugreifen. Schreibt dazu links in das Codefeld. Zunächst müsst ihr Obspy und alle notwendigen Module importieren, damit das Programm weiß, welches Tool zu verwenden ist. Macht dies direkt zu Beginn des Codes.

import obspy
from obspy.clients.fdsn import Client
from obspy import UTCDateTime

„Client“ erlaubt euch den Zugriff auf die FDSN-Daten der Erdbebendienste (Clients). Mit UTCDateTime könnt ihr Zeiten definieren, zum Beispiel bei Seismogrammen den Start- und den Endpunkt der Aufzeichnungen, die ihr abrufen möchtet.
Wichtig: Da wir es hier mit einer Programmiersprache zu tun haben, ist es beim Schreiben von Codes notwendig, auf Groß- und Kleinschreibung zu achten. Ansonsten treten Fehler auf.

Im folgenden Beispiel schauen wir uns den Vogtland-Erdbebenschwarm Ende 2020 an. Dessen aktivster Tag war der 19. Dezember. Wenn ihr also auf die Aufzeichnungen des Schwarms von diesem Tag zugreifen wollt, müsst ihr die Zeiten wie folgt definieren:

t = UTCDateTime("2020-12-18T23:00:00.000")
t2 = UTCDateTime("2020-12-19T23:00:00.000")

Statt t und t2 könnt ihr auch andere Bezeichnungen für diesen Wert wählen, x und y oder Startzeit und Endzeit zum Beispiel. Beachtet, dass alle definierten Zeiten der Zeitzone UTC entsprechen, also MEZ – 1h bzw. MESZ – 2h.

Nun müsst ihr festlegen, woher die Daten bezogen werden sollen. Dazu legt ihr zunächst den Client fest, hier ist das die BGR.

client = Client("BGR")

Neben dem Client benötigt ihr noch das Kürzel von Netzwerk, Station sowie dem Channel. Dies könnt ihr der oben verlinkten FDSN-Seite entnehmen. Wählt dazu einfach das jeweilige Netz (in diesem Fall das Sachsen-Netz SX). Dort findet ihr dann eine Karte und eine Liste mit allen verfügbaren Stationen und ihren Kürzeln. Hier wählen wir die Station „WERN“, welche dem Epizentrum am nächsten ist. Es fehlen noch der „Location Code“ und der „Channel“. Sind diese Werte nicht bekannt, kann man diese durch ein „*“ ersetzen. In dem Fall werden Daten von allen Location Codes und Channels, die zu der Station gehören, abgerufen. Wir schreiben also:

st = client.get_waveforms("SX","WERN", "*", "*", t, t2)

Mit dieser Zeile werden die entsprechenden Daten von FDSN bezogen und unter der Variable „st“ gespeichert. Nun müssen wir sie nur noch darstellen. Dazu verwenden wir den Befehl:

st.plot()

Unser Code sieht nun wie folgt aus

Um diesen nun auszuführen, müssen wir auf das grüne Dreieck in der Toolbar klicken („Run file“). Alternativ funktioniert auch F5. Das Ergebnis, das ihr dann oben rechts unter „Plots“ angezeigt bekommt, sieht so aus:

Leipzig University. (2001). SXNET Saxon Seismic Network. International Federation of Digital Seismograph Networks. https://doi.org/10.7914/SN/SX

Wir sehen hier die Aufzeichnungen über 24 Stunden an den verschiedenen Channels. Diese sind abgekürzt mit BH*, LH* und HH* sowie der jeweiligen Richtungskomponente *N (Nord), *E (Ost) und Z (vertikal). Auf der Y-Achse links ist die Amplitude des Signals (ohne Einheit) dargestellt, unten auf der X-Achse ist die Zeit. Alles in allem: Sehr unübersichtliche Darstellung. Das ganze geht deutlich schöner. Dazu wählen wir uns einen Channel, am besten den mit der höchsten Amplitude, weil dort dann in der Regel die Erdbebensignale am besten zu sehen sind. Dies wäre der Channel HHE. Dies fügen wir nun in die entsprechende Zeile ein:

st = client.get_waveforms("SX","WERN", "*", "HHE", t, t2)

Zudem wählen wir anstelle des bisherigen Darstellungsformats, was eher für geringe Zeiträume geeignet sind, das Format des Tagesplots. Dazu ersetzen wir st.plot() durch:

st.plot(type="dayplot", interval=30)

„Interval“ gibt die Anzahl der Minuten an, die in einer horizontalen Linie dargestellt sind. Lassen wir nun den Code laufen, bekommen wir:

Leipzig University. (2001). SXNET Saxon Seismic Network. International Federation of Digital Seismograph Networks. https://doi.org/10.7914/SN/SX

Deutlich übersichtlichere Darstellung, in der die Erdbebensignale gut zu sehen sind. Das ganze geht natürlich für jeden beliebigen Zeitraum und für jede beliebige Station.

Wenn ihr nicht wisst, welche Station, bzw. welches Netzwerk bei euch in der Nähe ist, könnt ihr statt der FDSN-Seite auch hier auf der IRIS-Website schauen. Diese gibt euch die Möglichkeit, Regionen auszuwählen und die verfügbaren seismologischen Stationen anzeigen zu lassen. Dazu wählt ihr links bei „Geographic Boundary“ den Punkt „Location Box“ aus und klickt anschließend auf „Draw Boundary“. Nun könnt ihr auf der Karte das Gebiet einzeichnen, für das ihr euch interessiert und euch anschließend über „Update Map“ die verfügbaren Stationen anzeigen lassen. Wenn ihr aus dem Zollernalbkreis kommt, könnte dies zum Beispiel so aussehen:

Ihr seht die Stationen mehrerer Netzwerke mit Stationscode, Koordinaten und Betriebszeitraum. Wenn ihr euch zum Beispiel das Erdbeben in Jungingen am 1. Dezember ansehen wollt, könnt ihr eine nahe gelegene Station wählen und auf der jeweils verlinkten Stationsseite schauen, ob und über welche Clients, von welchen Zeiträumen und für welche Channels Daten verfügbar sein. Hier nehmen wir mal die Station AM.RB411 in Tübingen. Diese ist über den Client „RASPISHAKE“ erreichbar und verfügt über den Channel SHZ, dessen Spektrum bis maximal 50Hz reicht.

Das Jungingen-Erdbeben war am 1. Dezember um 00:25 Uhr MEZ. In unserem Code schreiben wir also:

t = UTCDateTime("2020-11-30T23:25:00.000") 
t2 = UTCDateTime("2020-11-30T23:27:00.000")
client = obspy.clients.fdsn.Client("RASPISHAKE")
st = client.get_waveforms("AM","RB411", "*", "SHZ", t, t2)
st.plot()

und bekommen folgende Darstellung:

(1) Raspberry Shake Community; (2) OSOP, S.A.; (3) Gempa GmbH. (2016). Raspberry Shake. (1) OSOP, S.A.; (2) gempa GmbH. https://doi.org/10.7914/SN/AM

Das besondere an diesem Raspishake-Netzwerk ist, dass es sich nicht um Stationen von offiziellen Erdbebendiensten handelt. Stattdessen werden diese professionellen Mini-Seismometer von Privatpersonen oder Firmen aufgestellt und finanziert. Zwar verfügen diese Stationen meist nicht über die Bandbreite offizieller Stationen, doch sind die Daten oft gut genug, um bei der Aufzeichnung von Erdbeben zu helfen. Ein ruhiger Standort ist dafür natürlich notwendig. Zudem sind alle Aufzeichnungen via FDSN verfügbar. Wer also einen Beitrag zur seismologischen Überwachung leisten möchte oder einfach selbst Interesse daran hat, Erdbeben oder sonstige Erschütterungen in der Nachbarschaft aufzuzeichnen, über einen ruhigen Standort in Garten oder Keller verfügt und ein paar hundert Euro übrig hat, kann sich eine solche Station zulegen. Mehr Informationen dazu auf der Website von RaspberryShake.

Obspy bietet viele Optionen zum Anpassen der Darstellung, unter anderem auch das Filtern von bestimmten Frequenzen sowie die Farbwahl und die Beschriftungen. Das könnt ihr alles im Obspy-Tutorial nachlesen, wenn ihr daran Interesse habt. Hier geht es erstmal weiter mit dem Abrufen von Erdbebenkatalogen.

3. Zugriff auf Erdbebenkataloge und Abfrage früherer Erdbeben in einer Region

Wenn es irgendwo ein Erdbeben gibt, kommt oft die Frage auf, wann oder wie oft es in der Region schon früher Beben gegeben hat. Viele Erdbebendienste haben sogenannte Erdbebenkataloge, in der alle registrierten Erdbeben eines bestimmten Zeitraumes aufgelistet sind. Zum Teil sind diese Erdbebenkataloge im Web verfügbar, dann meist aber nur in Form riesiger PDF-, Text- oder Excel-Dateien. Auch hier bietet Obspy eine sehr hilfreiche Alternative, da viele Erdbebenkataloge über FDSN verfügbar sind. Dank Obspy sind es nur wenige Zeilen, mit denen man Kataloge abrufen, nach speziellen Kriterien filtern, auf Karten plotten oder auch in beliebigen Dateiformaten abspeichern kann.

Während der offizielle deutsche Erdbebenkatalog bis ins Jahr 800 zurückreicht, allerdings nicht via FDSN abrufbar ist, sind viele andere Kataloge meist auf einen kleineren Zeitraum beschränkt. Hier möchte ich euch den Katalog des Internationalen Seismologischen Dienstes (ISC) vorstellen. Dieser ist der wohl kompletteste Erdbebenkatalog der Welt und umfasst Daten dutzender Erdbebendienste. Er ist nicht minutenaktuell, aber für das 20. und das frühe 21. Jahrhundert die beste Quelle. Und natürlich über FDSN verfügbar.

Um einen Erdbebenkatalog abzurufen, müssen wir einen neuen Code schreiben. Dazu importieren wir zunächst wieder:

import obspy
from obspy import UTCDateTime

Danach müssen wir wieder einen Zeitraum definieren, der uns interessiert. Nehmen wir hier mal den 13. April 1992, den Tag des Roermond-Erdbebens.

t = UTCDateTime("1992-04-13T00:00:00.000") 
t2 = UTCDateTime("1992-04-14T00:00:00.000")

Wir fordern nun statt „waveforms“ diesmal „events“ an und legen dabei über Koordinaten ein Gebiet fest, für das wir Daten beziehen möchten. Da wir hier das Roermond-Erdbeben fokussieren, wählen wir Koordinaten, die diese Region miteinschließen.

client = obspy.clients.fdsn.Client("ISC")
events = client.get_events(minlatitude=50, maxlatitude=52,minlongitude=5,
maxlongitude=7, starttime=t,endtime=t2)

# Als weitere Parameter zum Filtern können unter anderem auch minmagnitude und
# maxmagnitude verwendet werden, um nur Beben einer bestimmten Stärke anzuzeigen.

Haben wir die Daten aus dem Katalog bezogen, können wir sie direkt via Obspy auf einer Karte plotten.

events.plot(projection="local")

Keine besonders schöne Darstellung ohne geographische Beschriftungen. Dargestellt sind nur die Epizentren auf einer kryptischen Hintergrundkarte sowie die jeweilige Magnitude und die Tiefe anhand der Farbskala. Wie das besser geht, zeige ich später in diesem Kapitel. Denn außer der Darstellung auf einer Karte, kann man die Katalogdaten auch einfach in der Console anzeigen lassen. Dazu verwenden wir statt „events.plot()“ den Befehl

print(events)

Nach dem Ausführen wird der Erdbebenkatalog für diesen Zeitraum zusammengefasst angezeigt:

33 Event(s) in Catalog:
1992-04-13T01:20:02.460000Z | +51.187, +5.784 | 5.48 mb
1992-04-13T01:31:08.000000Z | +51.170, +5.940 | 2.1 M 
...
1992-04-13T21:50:02.400000Z | +51.170, +5.990 | 2.1 M 
1992-04-13T22:59:21.800000Z | +51.150, +6.000 | 2.0 M

Neben der Stärke der Beben und dem Magnitudentyp sind auch die Koordinaten des Epizentrums sowie die genaue Uhrzeit im Katalog angegeben.

Wollt ihr diesen Datensatz nicht nur in der Console haben, sondern zum Beispiel in Google Earth oder Google Maps ansehen, könnt ihr euch die Liste als KML-Datei abspeichern. Dazu wählt einfach einen Namen und die Datei wird in dem Ordner gespeichert, indem sich auch euer Code befindet, den ihr mit Spyder erstellt.

events.write("Roermond.kml", format="KML")

Ihr könnt natürlich statt den hier verwendeten Koordinaten und Zeiträumen beliebige andere Werte verwenden. Bedenkt aber, dass der Erdbebenkatalog ziemlich lang wird, wenn ihr mit großen geographischen Gebieten, Zeiträumen und ohne Magnitudenlimit arbeitet. Entsprechend werden das auch große Datenmengen und ein enormer Rechenaufwand für den Computer.

Für aktuelle Erdbebendaten ist der ISC-Katalog wie gesagt nicht geeignet. Dafür könnt ihr zum Beispiel auf die Kataloge von USGS und EMSC zurückgreifen, die nahezu in Echtzeit aktualisiert werden.

Wenn ihr zum Beispiel die Erdbeben der letzten zwei Stunden anzeigen lassen wollt, könnt ihr dies so machen:

import obspy
from datetime import datetime
from obspy.clients.fdsn import Client
from obspy import UTCDateTime
now = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
t = UTCDateTime(now)
t2 = t - 7200
client = obspy.clients.fdsn.Client("EMSC")
events = client.get_events(starttime=t2,endtime=t)
print(events)

Über „datetime.now()“ definiert ihr den Zeitpunkt, zu dem ihr die Rechnung ausführt. Dies müsst ihr dann zunächst via UTCDateTime konvertieren. Anschließend könnt ihr einen zweiten Zeitpunkt definieren, der exakt zwei Stunden in der Vergangenheit liegt. Dazu müsst ihr vom ersten Wert 7200 (Sekunden) abziehen und diese Werte dann schließlich als Starttime (früherer Zeitpunkt) und Endtime (jetzt) festlegen. Das Ergebnis ist eine Liste der vom EMSC registrierten Erdbeben der letzten zwei Stunden (Abfrage vom 30. Januar, 17:45 Uhr):

Out: 
6 Event(s) in Catalog:
2021-01-30T16:23:07.000000Z | -31.840, -68.810 | 3.1 m | manual
2021-01-30T16:12:55.500000Z | +37.210, -3.680 | 1.9 ml | manual
2021-01-30T16:10:51.300000Z | +32.750, -115.820 | 2.7 ml | automatic
2021-01-30T15:56:07.000000Z | -27.810, -71.010 | 2.8 ml | manual
2021-01-30T15:50:14.300000Z | +32.640, -115.730 | 2.3 ml | automatic
2021-01-30T15:46:04.000000Z | +0.460, +98.590 | 3.4 m | manual

Bitte beachtet, dass das EMSC es nicht erlaubt, kürzere aktuelle Zeiträume abzufragen.

Im nächsten Schritt kann man nun die Daten aus einem Erdbebenkatalog auf einer vernünftigen Karte eintragen. Zur Arbeit mit Karten gibt es mehrere Module. Hier verwenden wir Cartopy, das wir bereits im Vorfeld installiert haben, sowie zum Plotten der Erdbebendaten Matplotlib. Cartopy ist ein relativ mächtiges Kartierungstool, das viele Arten der Darstellung erlaubt, viele Hintergrundkarten, viele Projektionen und Layout-Anpassungen. Da der folgende Code etwas komplexer wird, ergänze ich entsprechende Erklärungen innerhalb des Codes hinter Raute-Symbolen (#). Innerhalb eines Python-Skrips werden Rauten für Kommentare verwendet, dahinter stehende Texte nicht als Befehl gewertet, und beeinflussen daher auch nicht die Funktionalität der jeweiligen Zeile.

import obspy 
from datetime import datetime
from obspy import UTCDateTime
import cartopy.crs as ccrs 
import cartopy.io.img_tiles as cimgt
import matplotlib.pyplot as plt

now = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
t = UTCDateTime(now)
t2 = t - 86400 #Der Zeitraum wird auf die letzten 24h festgelegt.
client = obspy.clients.fdsn.Client("EMSC")
events = client.get_events(starttime=t2,endtime=t)

# Mit diesen Zeilen werden aus den Daten des Katalogs Magnitude sowie die Koordinaten
# (Latitude, Longitude) aller Erdbeben ausgelesen.
eventmagnitude,eventlongitude,eventlatitude = [],[],[]
for event in events: 
     ma = (event.preferred_magnitude().mag)
     eventmagnitude.append(ma**4) #Zur Darstellung auf der Karte werden die Magnituden
                                  #mit 4 potenziert
     lo = (event.preferred_origin().longitude)
     eventlongitude.append(lo)
     la = (event.preferred_origin().latitude)
     eventlatitude.append(la)

fig, ax = plt.subplots(figsize=(30,30)) #Legt Breite und Höhe der Karte fest
stamen_terrain = cimgt.Stamen('terrain') #Legt Stamen-Terrain als Hintergrundkarte fest
ax = plt.axes(projection=ccrs.Robinson()) #Legt Robinson-Projektion fest
#Folgende Zeilen legen die globale Darstellung fest. 
ax.set_global()
ax.add_image(stamen_terrain, 3)#Der Wert 3 legt die Auflösung der Karte fest
#Für regionale Darstellungen:
#extent = [lonmin, lonmax, latmin, latmax] #Legt die Größe des Kartenausschnitts fest
#ax.set_extent(extent, crs=ccrs.Geodetic())
#ax.add_image(stamen_terrain, 8) #Der Wert 8 legt die Auflösung der Karte fest

#Plottet die Erdbeben aus dem Katalog auf der Karte. Anhand der Magnitude wird die 
#Größe der Symbole (Standard: Kreise) bestimmt. Die Farben werden manuell festgelegt
#(rote Füllung, schwarzer Rand), ebenso die Dicke der Randlinie
plt.scatter(eventlongitude,eventlatitude,s=eventmagnitude,
c="red", edgecolor='black, linewidths=1.4, transform=ccrs.Geodetic())
#Erstellt eine Kartenlegende
for eventmagnitude in [3, 5, 7]:
     if eventmagnitude == 3:
          l = "Magnitude 3.0" 
     if eventmagnitude == 5:
          l = "Magnitude 5.0"
     if eventmagnitude == 7:
          l = "Magnitude 7.0"
plt.scatter([], [], c="red", alpha=1, s=eventmagnitude**4,label=str(l), 
edgecolor='black',transform=ccrs.Geodetic()) #Plottet die Legende
#Legt die Darstellung der Legendenpunkte fest und die Position fest
leg = plt.legend(scatterpoints=1, frameon=True, facecolor="lightgray",
labelspacing=0.7, fontsize=20, loc=2, bbox_to_anchor=(0, 0.195))
#Kartentitel mit Anpassung von Schriftgröße und Schriftart
Titel = "Erdbeben der letzten 24 Stunden. Daten: emsc-csem.org" 
ax.set_title(Titel, fontsize = 44, weight = 'bold', y=1.02) 

Das Ergebnis sieht wie folgt aus (Abfrage am 30. Januar um 18 Uhr)

Das Einlesen von Erdbebendaten kann zudem auch aus Dokumenten erfolgen. So kann man sich zum Beispiel über die Optionen der USGS-Website Erdbebenkataloge nach eigenen Optionen zusammenstellen und als CSV-Datei runterladen. Mit Pandas kann man diese Dateien bearbeiten und die wichtigen Werte (hier: Magnitude, Longitude und Latitude) auslesen. Dies funktioniert mit folgenden Zeilen:

import pandas as pd
import numpy as np
catalog = pd.read_csv("USGSCatalog.csv", delimiter=",") 
#Die CSV-Datei muss sich im gleichen Ordner wie der Code befinden)
eventlatitude = np.array(cateq["latitude"].values)
eventlongitude = np.array(cateq["longitude"].values)
eventmagnitude = np.array(cateq["mag"].values)

So bekommt man also via Obspy Zugriff auf die „Rohdaten“ in Form der Seismogramme, sondern auch auf die ausgewerteten Erdbebendaten. Durch Tools wie Cartopy ermöglichen sich viele Optionen zur Verarbeitung dieser Daten. Die hier dargestellten Funktionen sind nur ein sehr kleiner Teil dessen, was eigentlich möglich ist. Wer sich tiefer mit der Materie beschäftigen will, dem sei nochmal das Obspy-Tutorial empfohlen. Auch für Cartopy und alle anderen Module gibt es detaillierte Anleitungen mit vielen Anwendungsbeispielen online.

Ich hoffe, dass ihr Obspy, Python und die Möglichkeiten ebenso nützlich findet wie ich, und sei es nur zum Abrufen von Seismogrammen. Die freie Verfügbarkeit der Daten ist eine wichtige Errungenschaft der modernen Wissenschaft und wird inzwischen durch viele zivile Projekte unterstützt. Auch für Privatleute ist das eine gute Möglichkeit, einen tieferen Einblick zu bekommen. Zwar ist der Weg dahin nicht ganz einfach, aber mit dieser kurzen Einführung (und den vielen anderen Tutorials online) ist dieser hoffentlich ein wenig übersichtlicher geworden.

Sollten Fragen zu den hier dargestellten Methoden bestehen, könnt ihr die Kommentarfunktion nutzen.