def _download_cont(nw, starttime, endtime):
'''
Download data for each network
Return:
None
'''
print(f'======Download data for network {nw}: {starttime} - {endtime}======')
restrictions = Restrictions(
starttime = starttime,
endtime = endtime,
chunklength_in_sec = para["Station Info"].getint("chunksize", 1) * 24 * 60 * 60,
network = nw,
station = para["Station Info"].get("station", "*"),
channel_priorities = para["Station Info"].get("channelpri", "*").split(","),
reject_channels_with_gaps = False,
minimum_length = 0.0,
minimum_interstation_distance_in_m = 100.0)
mdl = MassDownloader(providers=["IRIS"])
mdl.download(
domain,
restrictions,
mseed_storage = para["DEFAULT"].get("projdir") + "/waveform/{station}/{network}.{station}.{location}.{channel}__{starttime}__{endtime}.mseed",
stationxml_storage = para["DEFAULT"].get("projdir") + "/station/{network}.{station}.xml")
return
def download_data(cat, downloaded=True):
import obspy
from obspy.clients.fdsn.mass_downloader import CircularDomain, \
Restrictions, MassDownloader
if downloaded == False:
# First, define a domain.
domain = CircularDomain(latitude=cat[0].origins[0].latitude,
longitude=cat[0].origins[0].longitude,
minradius=0.25,
maxradius=5.0)
# Second, define some additional restrictions.
restrictions = Restrictions(
starttime=cat[0].origins[0].time - 0.5 * 60,
endtime=cat[0].origins[0].time + 5 * 60,
minimum_interstation_distance_in_m=100E3,
channel="BHZ",
)
# If you leave the providers empty it will loop through
# all data centers it knows.
# It will prefer data from the first providers.
mdl = MassDownloader(providers=["SCEDC", "NCEDC", "IRIS"])
# Finally launch it.
mdl.download(domain,
restrictions,
mseed_storage="waveforms",
stationxml_storage="stations")
else:
print('Data has been downloaded')
def download_data(self, event, providers=None):
"""
"""
event = self.comm.events.get(event)
from obspy.clients.fdsn.mass_downloader import MassDownloader, \
Restrictions, GlobalDomain
proj = self.comm.project
if isinstance(proj.domain, lasif.domain.GlobalDomain):
domain = GlobalDomain()
else:
domain = self._get_spherical_section_domain(proj.domain)
event_time = event["origin_time"]
ds = proj.config["download_settings"]
starttime = event_time - ds["seconds_before_event"]
endtime = event_time + ds["seconds_after_event"]
mseed_storage = os.path.join(proj.paths["data"], event["event_name"],
"raw")
# Attempt to get StationXML data for a very long time span. This has
# the nice side effect that StationXML files will mostly be shared
# between events.
restrictions = Restrictions(
starttime=starttime,
endtime=endtime,
# Go back 10 years.
station_starttime=starttime - 86400 * 365.25 * 10,
# Advance 10 years.
station_endtime=endtime + 86400 * 365.25 * 10,
network=None, station=None, location=None, channel=None,
minimum_interstation_distance_in_m=ds[
"interstation_distance_in_m"],
reject_channels_with_gaps=True,
minimum_length=0.95,
location_priorities=ds["location_priorities"],
channel_priorities=ds["channel_priorities"])
stationxml_storage = self._get_stationxml_storage_fct(starttime,
endtime)
# Also log to file for reasons of provenance and debugging.
logger = logging.getLogger("obspy.clients.fdsn.mass_downloader")
fh = logging.FileHandler(
self.comm.project.get_log_file("DOWNLOADS", event["event_name"]))
fh.setLevel(logging.INFO)
FORMAT = "[%(asctime)s] - %(name)s - %(levelname)s: %(message)s"
formatter = logging.Formatter(FORMAT)
fh.setFormatter(formatter)
logger.addHandler(fh)
dlh = MassDownloader(providers=providers)
dlh.download(domain=domain, restrictions=restrictions,
mseed_storage=mseed_storage,
stationxml_storage=stationxml_storage)
def download_data(starttime,
endtime,
waveform_dir,
station_dir,
networks=None,
channels=None,
providers=None,
minimum_length=0.95):
# Rectangular domain containing parts of southern Germany.
domain = RectangularDomain(minlatitude=-90,
maxlatitude=90,
minlongitude=-180,
maxlongitude=180)
if isinstance(channels, list):
channel = ",".join(channels)
elif channels == "None" or channels is None:
channel = None
else:
raise ValueError("Unknown channels: {}".format(channels))
if isinstance(networks, list):
network = ",".join(networks)
elif networks == "None" or networks is None:
network = None
else:
raise ValueError("Unknown networks: {}".format(networks))
print("network: ", network)
print("channel: ", channel)
# Set download restrictions
restrictions = Restrictions(starttime=starttime,
endtime=endtime,
reject_channels_with_gaps=False,
minimum_length=minimum_length,
station=None,
network=network,
channel=channel,
location_priorities=["", "00", "10"],
channel_priorities=["BH[ZNE12]", "HH[ZNE12]"])
if (providers is None) or (providers == "None"):
mdl = MassDownloader()
else:
mdl = MassDownloader(providers=providers)
mdl.download(domain,
restrictions,
mseed_storage=waveform_dir,
stationxml_storage=station_dir)
def create_config(conf='conf.json', tutorial=False, less_data=False):
"""Create JSON config file and download tutorial data if requested"""
shutil.copyfile(resource_filename('yam', 'conf_example.json'), conf)
temp_dir = os.path.join(tempfile.gettempdir(), 'yam_example_data')
template = os.path.join(temp_dir, 'example_data')
station_template = os.path.join(temp_dir, 'example_inventory')
try:
num_files = (len([name for name in os.listdir(template)]),
len([name for name in os.listdir(station_template)]))
except FileNotFoundError:
num_files = (0, 0)
if tutorial and (num_files[0] <
(9 if less_data else 54) or num_files[1] < 3):
print('Download example data from Geofon')
from obspy import UTCDateTime as UTC
from obspy.clients.fdsn.mass_downloader import (GlobalDomain,
Restrictions,
MassDownloader)
domain = GlobalDomain()
restrictions = Restrictions(
starttime=UTC('2010-02-04' if less_data else '2010-02-01'),
endtime=UTC('2010-02-06' if less_data else '2010-02-15'),
network='CX',
station='PATCX',
location=None,
channel_priorities=["BH[ZN]"],
chunklength_in_sec=86400,
reject_channels_with_gaps=False,
minimum_length=0.5)
mdl = MassDownloader(providers=['GFZ'])
kw = dict(threads_per_client=1, download_chunk_size_in_mb=200)
mdl.download(domain, restrictions, template, station_template, **kw)
restrictions.station = 'PB06'
if not less_data:
restrictions.endtime = UTC('2010-02-12')
mdl.download(domain, restrictions, template, station_template, **kw)
restrictions.station = 'PB01'
restrictions.endtime = UTC('2010-02-04 08:00:00')
restrictions.channel_priorities = ["BHZ"]
mdl.download(domain, restrictions, template, station_template, **kw)
if not less_data:
restrictions.starttime = UTC('2010-02-08 00:00:00')
restrictions.endtime = UTC('2010-02-09 23:55:00')
restrictions.channel_priorities = ["BHZ"]
mdl.download(domain, restrictions, template, station_template,
**kw)
if tutorial:
dest_dir = os.path.dirname(conf)
dest_dir_data = os.path.join(dest_dir, 'example_data')
dest_dir_inv = os.path.join(dest_dir, 'example_inventory')
if not os.path.exists(dest_dir_data):
if less_data:
ignore = shutil.ignore_patterns('*2010020[123]T000000Z__*',
'*2010020[6-9]T000000Z__*',
'*2010021?T000000Z__*')
else:
ignore = None
shutil.copytree(template, dest_dir_data, ignore=ignore)
if not os.path.exists(dest_dir_inv):
shutil.copytree(station_template, dest_dir_inv)
def descargar_datos(cat, radiomin, radiomax, start_time, end_time, dist_esta):
nombre_evento = cat["region"].values[0]
fecha_evento = cat["fecha_evento"].values[0]
magnitud = cat["Mw_cmt"].values[0]
nombre_evento = str(nombre_evento + " " + str(fecha_evento) + " " +
str(magnitud)) # + str(canal)
lat_e = cat["lat_cmt"].values[0]
lon_e = cat["lon_cmt"].values[0]
time = cat["tiempo_cmt"].values[0]
time = str(fecha_evento) + "T" + time
time = UTCDateTime(time)
depth = cat["depth_cmt"].values[0]
client = Client("IRIS")
domain = CircularDomain(latitude=lat_e,
longitude=lon_e,
minradius=radiomin,
maxradius=radiomax)
mdl = MassDownloader(providers=["IRIS"])
restrictions = Restrictions(starttime=time - start_time,
endtime=time + end_time,
chunklength_in_sec=86400,
location="00",
channel="BHZ",
reject_channels_with_gaps=True,
minimum_length=0.95,
minimum_interstation_distance_in_m=dist_esta,
sanitize=True)
ruta = os.getcwd()
rutas = "datos/"
informacion = ruta + "/" + rutas + nombre_evento
n_carpeta_w = nombre_evento + "/waveforms"
n_carpeta_s = nombre_evento + "/stations"
informacion = informacion.replace("/", "\\")
try:
os.mkdir(informacion)
os.chdir(informacion)
archivo = open("info.txt", "w")
archivo.write(str(cat["id_evento"].values[0]) + "\n")
archivo.close()
os.chdir("..")
mdl.download(domain,
restrictions,
mseed_storage=n_carpeta_w,
stationxml_storage=n_carpeta_s)
except:
return -100
def download(eqname, t0, min_length=600):
domain = GlobalDomain()
restrictions = Restrictions(starttime=t0,endtime=t0+min_length,chunklength_in_sec=84600,network="*", station="*", location="", channel="BH*",
reject_channels_with_gaps=True,minimum_length=0.0,minimum_interstation_distance_in_m=100.0)
waveform_dir = "data/{}/waveforms".format(eqname)
stationxml_dir = "data/{}/stations".format(eqname)
makedir(waveform_dir)
makedir(stationxml_dir)
mdl = MassDownloader(providers=["http://eida.koeri.boun.edu.tr:8080"])
# Kandilli FDSN matchtimeseries=True icin bos istasyon listesi donduruyor.
mdl._initialized_clients["http://eida.koeri.boun.edu.tr:8080"].services["station"].pop("matchtimeseries")
mdl.download(domain, restrictions,
mseed_storage=waveform_dir,
stationxml_storage=stationxml_dir)
def download_global_data(starttime,
endtime,
waveform_dir,
stationxml_dir,
stations=None,
networks=None,
channels=None,
location_priorities=None,
channel_priorities=None,
minimum_length=0.95,
reject_channels_with_gaps=True,
providers=None):
domain = GlobalDomain()
station = list2str(stations)
network = list2str(networks)
channel = list2str(channels)
print("network {}: | station: {} | channel: {} ".format(
network, station, channel))
time.sleep(2.0)
# Set download restrictions
restrictions = Restrictions(
starttime=starttime,
endtime=endtime,
reject_channels_with_gaps=reject_channels_with_gaps,
minimum_length=minimum_length,
station=station,
network=network,
channel=channel,
location_priorities=location_priorities,
channel_priorities=channel_priorities)
if (providers is None) or (providers == "None"):
mdl = MassDownloader()
else:
mdl = MassDownloader(providers=providers)
mdl.download(domain,
restrictions,
mseed_storage=waveform_dir,
stationxml_storage=stationxml_dir)
def get_data(date, latitude, longitude):
resp_files = '/Users/gsilveira/Documents/MadalenaMatias/dataless/resp/'
from obspy.clients.fdsn.mass_downloader import RectangularDomain, \
Restrictions, MassDownloader
domain = RectangularDomain(
minlatitude=-55.5,
maxlatitude=latitude, #66.7,
minlongitude=-71.5,
maxlongitude=longitude)
restrictions = Restrictions(
# Get data for a whole year.
starttime=obspy.UTCDateTime(int(date[0]), int(date[1]), int(date[2]),
int(date[3]), int(date[4]), int(date[5]),
int(date[6])),
endtime=obspy.UTCDateTime(2020, 10, 1),
# Chunk it to have one file per day.
chunklength_in_sec=3600000,
# Considering the enormous amount of data associated with continuous
# requests, you might want to limit the data based on SEED identifiers.
# If the location code is specified, the location priority list is not
# used; the same is true for the channel argument and priority list.
network="GH",
station="AKOS",
location="*",
channel="*",
# The typical use case for such a data set are noise correlations where
# gaps are dealt with at a later stage.
reject_channels_with_gaps=False,
# Same is true with the minimum length. All data might be useful.
minimum_length=0.0,
# Guard against the same station having different names.
minimum_interstation_distance_in_m=100.0)
# Restrict the number of providers if you know which serve the desired
# data. If in doubt just don't specify - then all providers will be
# queried.
mdl = MassDownloader(providers=["IRIS"])
mdl.download(
domain,
restrictions,
mseed_storage=("../per_hour/{network}/Leslie/{station}/"
"{channel}.{location}.{starttime}.{endtime}.mseed"),
stationxml_storage="stations")
def _download_event(eventtime, starttime, endtime):
'''
Download each event for all stations
Return:
None
'''
restrictions = Restrictions(
starttime = eventtime - starttime * 60,
endtime = eventtime + endtime * 60,
network = para["Station Info"].get("network", "*"),
station = para["Station Info"].get("station", "*"),
reject_channels_with_gaps = False,
minimum_length = 0.0,
channel_priorities = para["Station Info"].get("channelpri", "*").split(","))
mdl = MassDownloader(providers=["IRIS"])
mdl.download(
domain,
restrictions,
mseed_storage = f'{para["DEFAULT"].get("projdir")}/waveform',
stationxml_storage = f'{para["DEFAULT"].get("projdir")}/station')
return
def download_events(cat, yeartag="2005", firstid=1):
"""
Download events to lower 48 with MassDownloader using
events in obspy Catalog object cat. Parameters for
station definitions are hard wired
"""
wf_storage = yeartag + "/{starttime}/{network}_{station}_{location}.mseed"
site_storage = "site_" + yeartag + ".dir"
mdl = MassDownloader()
domain = RectangularDomain(minlatitude=20.0,
maxlatitude=54.0,
minlongitude=-135,
maxlongitude=-55)
count_evid = 1
for event in cat:
if (count_evid >= firstid):
t0 = time.time()
o = event.preferred_origin()
# Time attribute is already a UTCDateTime object
origin_time = o.time
restrictions = Restrictions(
starttime=origin_time,
endtime=origin_time + 3600.0,
reject_channels_with_gaps=True,
minimum_length=0.95,
minimum_interstation_distance_in_m=100.0,
channel_priorities=["BH[ZNE12]"],
location_priorities=["", "00", "10", "01"])
wf_storage = ("%s/event%d" % (yeartag, count_evid))
mdl.download(domain,
restrictions,
mseed_storage=wf_storage,
stationxml_storage=site_storage)
dt = time.time() - t0
print("Event ", count_evid, " download time (s)=", dt)
count_evid += 1
def run_get_waveform(self):
"""
Get SAC waveforms for an event
basic usage:
run_get_waveform(event)
c - client
event - obspy Event object
ref_time_place - reference time and place (other than origin time and place - for station subsetting)
"""
#c = self.client
event = self.ev
ref_time_place = self.ref_time_place
evtime = event.origins[0].time
reftime = ref_time_place.origins[0].time
#-----------------------------------------------------------
# BEGIN OPTIONS MASS DOWNLOADER
#-----------------------------------------------------------
#if self.ifmass_downloader is True:
if self.idb is not None and self.ifmass_downloader is True:
domain = CircularDomain(
latitude =self.elat,
longitude=self.elon,
minradius=kilometer2degrees(self.min_dist),
maxradius=kilometer2degrees(self.max_dist))
print('DEBUG. domain radius (deg) min/max %f/%f (input, km %f)' %
(domain.minradius, domain.maxradius, self.max_dist))
print('DEBUG. lon/lat %f/%f' %
(domain.longitude, domain.latitude))
restrictions = Restrictions(
starttime = reftime - self.tbefore_sec,
endtime = reftime + self.tafter_sec,
#station_starttime = None,
#station_endtime = None,
station_starttime = reftime - self.tbefore_sec, # 2021-06-25 TEST. only query stations available during the event times.
station_endtime = reftime + self.tafter_sec,
chunklength_in_sec = None,
network = self.network,
station = self.station,
location = self.location,
channel = self.channel,
#exclude_networks = (),
#exclude_stations = (),
#limit_stations_to_inventory=None,
reject_channels_with_gaps=False,
minimum_length = 0.0,
sanitize = True,
minimum_interstation_distance_in_m = 100, # 2021-07-13 avoid using same station with different names
#channel_priorities=(),
#location_priorities=())
)
mdl = MassDownloader()
outdir = './' + self.evname
mdl.download(domain=domain, restrictions=restrictions,
mseed_storage=outdir+"/mass_downloader/waveforms",
stationxml_storage=outdir+"/mass_downloader/stations",
download_chunk_size_in_mb=20, threads_per_client=3, print_report=True)
inventory = get_inventory_from_xml(outdir+"/mass_downloader/stations")
stream_raw = get_streams_from_dir(outdir+"/mass_downloader/waveforms")
print(inventory)
phases = self.phases
t1s, t2s= get_phase_arrival_times(inventory,event,self.phases,
self.phase_window,self.taupmodel,
reftime,self.tbefore_sec,self.tafter_sec)
# End mass downloader
#-----------------------------------------------------------
#-----------------------------------------------------------
# Pick client
#-----------------------------------------------------------
# Add deprecation warning
if self.idb is not None:
print('WARNING: Instead of idb use which client you want to use \n'\
' By default ev_info.client_name is set to IRIS')
if self.idb == 3:
self.client_name = "LLNL"
if self.client_name != "LLNL" and self.ifmass_downloader is False:
# Send request to client
# There might be other way to do this using 'RoutingClient'
print("Sending request to client: %s" % self.client_name)
c = self.client
print(c)
# Check if stations chosen are correct
# Example: NCEDC does not understand '-XXX' station code
if self.client_name == "NCEDC":
if '-' in self.station:
raise ValueError("NCEDC client does not take '-' in station code")
if self.client_name == "IRIS":
if '*' in self.network:
print("WARNING: You have chosen to search ALL networks at IRIS." \
"This could take long!")
#-----------------------------
if self.ifph5:
STATION = 'http://service.iris.edu/ph5ws/station/1'
c = fdsn.client.Client('http://service.iris.edu',
service_mappings={
'station': STATION
},
debug=True
)
#-----------------------------------------------------------
# Download stations
#-----------------------------------------------------------
print("Download stations...")
stations = c.get_stations(network=self.network, location=self.location,
station=self.station, channel=self.channel,
starttime=reftime - self.tbefore_sec,
endtime=reftime + self.tafter_sec,
minlatitude=self.min_lat,
maxlatitude=self.max_lat,
minlongitude=self.min_lon,
maxlongitude=self.max_lon,
level="response")
inventory = stations # so that llnl and iris scripts can be combined
if self.ifverbose:
print("Printing stations")
print(stations)
print("Done Printing stations...")
sta_limit_distance(ref_time_place,
stations,
min_dist=self.min_dist,
max_dist=self.max_dist,
min_az=self.min_az,
max_az=self.max_az,
ifverbose=self.ifverbose)
#print("Printing stations NEW")
#print(stations)
#print("Done Printing stations...")
#stations.plotprojection="local")
# Find P and S arrival times
phases = self.phases
t1s, t2s= get_phase_arrival_times(stations,event,self.phases,
self.phase_window,self.taupmodel,
reftime,self.tbefore_sec,self.tafter_sec)
print("Downloading waveforms...")
# this needs to change
bulk_list = make_bulk_list_from_stalist(stations,t1s,t2s,
channel=self.channel)
if self.ifph5:
DATASELECT = 'http://service.iris.edu/ph5ws/dataselect/1'
c = fdsn.client.Client('http://service.iris.edu',
service_mappings={
'dataselect': DATASELECT
},
user = self.user,password = self.password,
debug=True
)
stream_raw = c.get_waveforms(network=self.network, location=self.location,
station=self.station, channel=self.channel,
starttime=reftime - self.tbefore_sec,
endtime=reftime + self.tafter_sec)
else:
stream_raw = c.get_waveforms_bulk(bulk_list)
# save ev_info object
pickle.dump(self,open(self.evname + '/' +
self.evname + '_ev_info.obj', 'wb'))
elif self.client_name=="LLNL" and self.ifmass_downloader is False:
#client_name = "LLNL"
print("Preparing request for LLNL ...")
# Get event an inventory from the LLNL DB.
event_number = int(event.event_descriptions[0].text)
# event = llnl_db_client.get_obspy_event(event)
inventory = c.get_inventory()
nsta_llnl = len(inventory.get_contents()["stations"])
print("--> Total stations in LLNL DB: %i" % nsta_llnl)
sta_limit_distance(event, inventory,
min_dist=self.min_dist,
max_dist=self.max_dist,
min_az=self.min_az,
max_az=self.max_az)
print("--> Stations after filtering for distance: %i" % (
len(inventory.get_contents()["stations"])))
stations = set([sta.code for net in inventory for sta in net])
_st = c.get_waveforms_for_event(event_number)
stream_raw = obspy.Stream()
for tr in _st:
if tr.stats.station in stations:
stream_raw.append(tr)
# set reftime
#inventory = stations
stream = obspy.Stream()
stream = set_reftime(stream_raw, evtime)
nsta = len(stream)
if nsta < 1:
print('STOP. No waveforms to process. N stations = %d\n' % nsta)
sys.exit()
print("--> Adding SAC metadata...")
if self.ifverbose: print(stream.__str__(extended=True))
st2 = add_sac_metadata(stream, client_name=self.client_name, ev=event,
inventory=inventory, taup_model= self.taupmodel,
)
# 2022-03-10 CHECK IF NEEDED: stalist=inventory.
# phases=phases, phase_write = self.write_sac_phase)
print('stalist inventory', inventory)
if(len(st2)<1):
print('STOP. No waveforms left to process.')
sys.exit()
# Do some waveform QA
do_waveform_QA(st2, self.client_name, event, evtime,
self.tbefore_sec, self.tafter_sec)
if self.demean:
st2.detrend('demean')
if self.detrend:
st2.detrend('linear')
if self.ifFilter:
prefilter(st2, self.f1, self.f2,
self.zerophase, self.corners, self.filter_type)
if self.remove_response:
resp_plot_remove(st2, self.ipre_filt, self.pre_filt,
self.iplot_response, self.water_level,
self.scale_factor,
inventory, self.outformat, self.ifverbose)
else:
# output RAW waveforms
decon=False
print("WARNING -- NOT correcting for instrument response")
if self.scale_factor > 0:
amp_rescale(st2, self.scale_factor)
if self.client_name == "LLNL":
amp_rescale_llnl(st2, self.scale_factor)
# Set the sac header KEVNM with event name
# This applies to the events from the LLNL database
# NOTE this command is needed at the time of writing files, so it has to
# be set early
st2, evname_key = rename_if_LLNL_event(st2, evtime)
self.evname = evname_key
# save station plot
# Note: Plotted are stations in the inventory and NOT the ones with the traces
# It could be possible that there might not be waveforms for some of these stations.
try:
fig = inventory.plot(projection="local", resolution="i", label = False, show=False)
Catalog([self.ev]).plot(fig=fig, outfile=self.evname + '/station_map.pdf')
except:
print("There is a problem with creating the station map!")
# Get list of unique stations + locaiton (example: 'KDAK.00')
stalist = []
for tr in stream.traces:
if self.ifverbose: print(tr)
station_key = "%s.%s.%s.%s" % (tr.stats.network, tr.stats.station,
tr.stats.location, tr.stats.channel[:-1])
stalist.append(station_key)
# Crazy way of getting a unique list of stations
stalist = list(set(stalist))
# Resample
if self.resample_TF == True:
print('\nRESAMPLING DATA\n')
print("New sample rate %f Hz" % self.resample_freq)
# NOTE !!! tell the user if BOTH commands are disabled NOTE !!!
if (self.client_name == "IRIS"):
resample(st2, freq=self.resample_freq)
elif (self.client_name == "LLNL"):
resample_cut(st2, self.resample_freq, evtime, self.tbefore_sec, self.tafter_sec)
else:
print("WARNING. Will not resample. Using original rate from the data: %f Hz" % self.resample_freq)
# match start and end points for all traces
st2 = trim_maxstart_minend(stalist, st2, self.client_name, event, evtime,
self.resample_TF, self.resample_freq,
self.tbefore_sec, self.tafter_sec, self.ifverbose)
if len(st2) == 0:
raise ValueError("no waveforms left to process!")
# save raw waveforms in SAC format
if self.isave_raw:
path_to_waveforms = evname_key + "/RAW"
write_stream_sac_raw(stream_raw, path_to_waveforms,
evname_key, self.client_name, event, stations=inventory)
# Taper waveforms (optional; Generally used when data is noisy- example: HutchisonGhosh2016)
# https://docs.obspy.org/master/packages/autogen/obspy.core.trace.Trace.taper.html
# To get the same results as the default taper in SAC, use max_percentage=0.05 and leave type as hann.
# Note: Tapering also happens while resampling (see util_write_cap.py)
if self.taper:
st2.taper(max_percentage=self.taper, type='hann',max_length=None, side='both')
# save processed waveforms in SAC format
# evname_key/RAW_processed = traces after waveform_QA + demean + detrend +
# resample + remove response + filtering +
# resampling + scaling + tapering
# NOTE: The orientation is same as that of extracted waveforms
# Waveforms are rotated to ENZ, in case they are not already orientated,
# in the next step (self.rotateRTZ)
if self.isave_raw_processed:
path_to_waveforms = os.path.join(evname_key, 'RAW_processed')
write_stream_sac(st2, path_to_waveforms, evname_key)
# Rotate to ENZ (save: optional)
#if self.rotateENZ:
#st2 = rotate2ENZ(st2, evname_key, self.isave_ENZ, self.icreateNull, self.ifverbose)
print ('\nBEGIN ROTATE COMPONENTS')
if self.rotateENZ:
st2 = rotate2ENZ(st2, evname_key, self.isave_ENZ, self.icreateNull, self.ifverbose)
# rotate to UVW and save
if self.rotateUVW:
rotate2UVW(st2, evname_key)
# Rotate to RTZ and save
if self.rotateRTZ:
rotate2RTZ(st2, evname_key, self.ifverbose)
# save CAP weight files
if self.output_cap_weight_file:
write_cap_weights(st2, evname_key, self.client_name, event, self.ifverbose)
# save event info
if self.output_event_info:
write_ev_info(event, evname_key)
# Plot spectrograms
if self.ifplot_spectrogram:
plot_spectrogram(st2, evname_key)
# save pole zero file (Needed for MouseTrap)
if self.ifsave_sacpaz:
write_resp(inventory,evname_key)
# save station inventory as XML file
if self.ifsave_stationxml:
xmlfilename = evname_key + "/stations.xml"
try:
inventory.write(xmlfilename, format="stationxml", validate=True)
except:
print('Could not create stationxml file')
# Path to the asdf_converter script
if self.ifsave_asdf:
# save RTZ
asdf_filename = evname_key + "/" + evname_key + ".h5"
os.system("../asdf_converters/asdf_converters/sac2asdf.py "
+ evname_key + " " + asdf_filename + " observed")
# save NEZ
nez_dir = evname_key + "/ENZ/"
nez_asdf_filename = nez_dir + evname_key + ".h5"
os.system("../asdf_converters/asdf_converters/sac2asdf.py "
+ nez_dir + " " + nez_asdf_filename + " observed")
print ('\nDone processing waveform data for event %s' % evname_key)
def get_mass_data(network,
starttime,
endtime,
outdir='.',
lat=0,
lon=0,
minrad=0,
maxrad=180,
providers=['IRIS']):
"""
Use obspy's massdownloader to download lots of data, stores as day-long \
miniseed files using IRIS DMC naming conventions.
:type network: str
:param network: Network code
:type starttime: UTCDateTime
:param starttime: Time to begin donloading from, will use the date
:type endtime: UTCDateTime
:param endtime: Time to end download, will use the date
:type outdir: str
:param outdir: Path to write to, will write in Y????/R???.01 directories \
within this head directory.
:type lat: float
:param lat: Origin latitude
:type lon: float
:param lon: Origin longitude
:type minrad: float
:param minrad: Minumum radius in degrees for stations from lat/lon.
:type maxrad: float
:param maxrad: Maximum radius in degrees for stations from lat/lon
:type providers: list
:param providers: List of providers to query. Default is IRIS. Can parse \
an empty list and will query all providers, but slow.
.. note:: Currently selects data using a circular domain, default is \
set to entire globe so that a whole network can be downloaded. \
Options left in function to allow repurposing.
"""
def get_mseed_storage(network, station, location, channel, starttime,
endtime):
"""Function to define the naming for the stored file.
.. note:: Can only have these arguments. As such this needs to be a \
function defined within the other function to have access to the \
outdir variable.
"""
import os
# Returning True means that neither the data nor the StationXML file
# will be downloaded.
# If a string is returned the file will be saved in that location.
path = os.path.join(
outdir, "%s/%s.%s.%s.%s.%s" %
(starttime.strftime('Y%Y/R%j.01'), network, station, location,
channel, starttime.strftime('%Y.%j')))
if os.path.exists(path):
return True
return path
import obspy
from obspy.clients.fdsn.mass_downloader import CircularDomain, \
Restrictions, MassDownloader
domain = CircularDomain(latitude=lat,
longitude=lon,
minradius=minrad,
maxradius=maxrad)
restrictions = Restrictions(
# Get data for a whole year.
starttime=starttime,
endtime=endtime,
# Chunk it to have one file per day.
chunklength_in_sec=86400,
# Considering the enormous amount of data associated with continuous
# requests, you might want to limit the data based on SEED identifiers.
# If the location code is specified, the location priority list is not
# used; the same is true for the channel argument and priority list.
network=network,
station="NA390",
location="*",
channel="H*",
# The typical use case for such a data set are noise correlations where
# gaps are dealt with at a later stage.
reject_channels_with_gaps=False,
# Same is true with the minimum length. All data might be useful.
minimum_length=0.0,
# Guard against the same station having different names.
minimum_interstation_distance_in_m=0.0,
# Do not sanitize downloads, currently a bug
sanitize=False,
location_priorities=("", "01", "00", "EP", "S1", "S3", "02", "10",
"09", "08", "03", "04", "06", "07", "05", "20",
"T0", "2C", "40", "50"))
# Restrict the number of providers if you know which serve the desired
# data. If in doubt just don't specify - then all providers will be
# queried.
mdl = MassDownloader(providers=providers)
mseed_storage = get_mseed_storage
# + "/{station}.{network}.{location}.{channel}.{starttime}")
mdl.download(domain,
restrictions,
mseed_storage=mseed_storage,
stationxml_storage="stations",
threads_per_client=5)
def retrieveData(self):
"""Retrieve data from many FDSN services, turn into StreamCollection.
Args:
event (dict):
Best dictionary matching input event, fields as above
in return of getMatchingEvents().
Returns:
StreamCollection: StreamCollection object.
"""
# Bail out if FDSNFetcher not configured
if 'FDSNFetcher' not in self.config['fetchers']:
return
rawdir = self.rawdir
if self.rawdir is None:
rawdir = tempfile.mkdtemp()
else:
if not os.path.isdir(rawdir):
os.makedirs(rawdir)
# use the mass downloader to retrieve data of interest from any FSDN
# service.
origin_time = UTCDateTime(self.time)
# The Obspy mass downloader has it's own logger - grab that stream
# and write it to our own log file
ldict = logging.Logger.manager.loggerDict
if OBSPY_LOGGER in ldict:
root = logging.getLogger()
fhandler = root.handlers[0]
obspy_logger = logging.getLogger(OBSPY_LOGGER)
obspy_stream_handler = obspy_logger.handlers[0]
obspy_logger.removeHandler(obspy_stream_handler)
obspy_logger.addHandler(fhandler)
# Circular domain around the epicenter.
domain = CircularDomain(latitude=self.lat,
longitude=self.lon,
minradius=0,
maxradius=self.radius)
min_dist = self.minimum_interstation_distance_in_m
restrictions = Restrictions(
# Define the temporal bounds of the waveform data.
starttime=origin_time - self.time_before,
endtime=origin_time + self.time_after,
network=self.network,
station='*',
location='*',
location_priorities=['*'],
reject_channels_with_gaps=self.reject_channels_with_gaps,
# Any trace that is shorter than 95 % of the
# desired total duration will be discarded.
minimum_length=self.minimum_length,
sanitize=self.sanitize,
minimum_interstation_distance_in_m=min_dist,
exclude_networks=self.exclude_networks,
exclude_stations=self.exclude_stations,
channel_priorities=self.channels)
# For each of the providers, check if we have a username and password
# provided in the config. If we do, initialize the client with the
# username and password. Otherwise, use default initalization.
client_list = []
for provider_str in URL_MAPPINGS.keys():
if provider_str == GEO_NET_ARCHIVE_KEY:
dt = UTCDateTime.utcnow() - UTCDateTime(self.time)
if dt < GEONET_ARCHIVE_DAYS:
provider_str = GEONET_REALTIME_URL
try:
fdsn_config = self.config['fetchers']['FDSNFetcher']
if provider_str in fdsn_config:
client = Client(
provider_str,
user=fdsn_config[provider_str]['user'],
password=fdsn_config[provider_str]['password'])
else:
client = Client(provider_str)
client_list.append(client)
# If the FDSN service is down, then an FDSNException is raised
except FDSNException:
logging.warning('Unable to initalize client %s' % provider_str)
except KeyError:
logging.warning('Unable to initalize client %s' % provider_str)
if len(client_list):
# Pass off the initalized clients to the Mass Downloader
mdl = MassDownloader(providers=client_list)
logging.info('Downloading new MiniSEED files...')
# The data will be downloaded to the ``./waveforms/`` and
# ``./stations/`` folders with automatically chosen file names.
mdl.download(domain,
restrictions,
mseed_storage=rawdir,
stationxml_storage=rawdir)
seed_files = glob.glob(os.path.join(rawdir, '*.mseed'))
streams = []
for seed_file in seed_files:
try:
tstreams = read_obspy(seed_file, self.config)
except BaseException as e:
tstreams = None
fmt = 'Could not read seed file %s - "%s"'
logging.info(fmt % (seed_file, str(e)))
if tstreams is None:
continue
else:
streams += tstreams
stream_collection = StreamCollection(
streams=streams, drop_non_free=self.drop_non_free)
return stream_collection
def download_data(self, event: str, providers: List[str] = None):
"""
Download data using the obspy mass downloader
:param event: Name of event
:type event: str
:param providers: List of providers, defaults to None
:type providers: List[str], optional
"""
event = self.comm.events.get(event)
from obspy.clients.fdsn.mass_downloader import (
MassDownloader,
Restrictions,
)
proj = self.comm.project
domain = self._get_hdf5_domain(proj.domain)
event_time = event["origin_time"]
ds = proj.lasif_config["download_settings"]
starttime = event_time - ds["seconds_before_event"]
endtime = event_time + ds["seconds_after_event"]
event_name = event["event_name"]
if ds["networks"] == "None":
ds["networks"] = None
restrictions = self.generate_restrictions(starttime=starttime,
endtime=endtime,
ds=ds)
filename = proj.paths["eq_data"] / (event["event_name"] + ".h5")
import pyasdf
asdf_ds = pyasdf.ASDFDataSet(filename, compression="gzip-3")
stationxml_storage_path = (proj.paths["eq_data"] /
f"tmp_station_xml_storage_{event_name}")
stationxml_storage = self._get_stationxml_storage_fct(
asdf_ds, starttime, endtime, stationxml_storage_path)
mseed_storage_path = (proj.paths["eq_data"] /
f"tmp_mseed_storage_{event_name}")
mseed_storage = self._get_mseed_storage_fct(asdf_ds, starttime,
endtime,
mseed_storage_path)
# Also log to file for reasons of provenance and debugging.
logger = logging.getLogger("obspy.clients.fdsn.mass_downloader")
fh = logging.FileHandler(
self.comm.project.get_log_file("DOWNLOADS", event_name))
fh.setLevel(logging.INFO)
FORMAT = "[%(asctime)s] - %(name)s - %(levelname)s: %(message)s"
formatter = logging.Formatter(FORMAT)
fh.setFormatter(formatter)
logger.addHandler(fh)
dlh = MassDownloader(providers=providers)
dlh.download(
domain=domain,
restrictions=restrictions,
mseed_storage=mseed_storage,
stationxml_storage=stationxml_storage,
threads_per_client=1,
download_chunk_size_in_mb=50.0,
)
import glob
files = glob.glob(str(mseed_storage_path / "*.mseed"))
for _i, filename in enumerate(files):
print("Adding raw_recording %i of %i ..." % (_i + 1, len(files)))
try:
asdf_ds.add_waveforms(filename,
tag="raw_recording",
event_id=asdf_ds.events[0])
except Exception as e:
print(e)
files = glob.glob(str(stationxml_storage_path / "*.xml"))
for _i, filename in enumerate(files):
print("Adding stationxml %i of %i ..." % (_i + 1, len(files)))
try:
asdf_ds.add_stationxml(filename)
except Exception as e:
print(e)
# remove stations with missing information
for station in asdf_ds.waveforms.list():
station_inventory = asdf_ds.waveforms[station].list()
if ("StationXML" not in station_inventory
or len(station_inventory) < 2):
del asdf_ds.waveforms[station]
msg = (f"Removed station {station} due to missing "
f"StationXMl or waveform information.")
print(msg)
continue
# if coordinates are specified at the channel and are different
# skip and remove, perhaps add a tolerance here in the future.
else:
obspy_station = asdf_ds.waveforms[station].StationXML[0][0]
if not obspy_station.channels:
continue
else:
coords = set((_i.latitude, _i.longitude, _i.depth)
for _i in obspy_station.channels)
if len(coords) != 1:
del asdf_ds.waveforms[station]
msg = (f"Removed station {station} due to "
f"inconsistent channel coordinates.")
print(msg)
# clean up temporary download directories
import shutil
if os.path.exists(stationxml_storage_path):
shutil.rmtree(stationxml_storage_path)
if os.path.exists(mseed_storage_path):
shutil.rmtree(mseed_storage_path)
def FDSN_downloader(datapath,
start='20141201',
stop='20161201',
network='XH',
station='*',
channel='HH*',
**kwargs):
"""This function uses the FDSN mass data downloader to automatically
download data from the XH network deployed on the RIS from Dec 2014 - Dec
2016. More information on the Obspy mass downloader available at:
https://docs.obspy.org/packages/autogen/obspy.clients.fdsn.mass_downloader.html
Parameters
----------
datapath : str
Path to save MSEED and XML data.
start : str
Start date, in format YYYYMMDD
stop : str
Stop date, in format YYYYMMDD
network : str
2-character FDSN network code
station: str
2-character station code
channel: str
3-character channel code
"""
print("=" * 65)
print("Initiating mass download request.")
start = UTCDateTime(start)
stop = UTCDateTime(stop)
if not os.path.exists(datapath):
# os.makedirs(f'{datapath}/MSEED')
os.makedirs(os.path.join(datapath, 'MSEED'))
# os.makedirs(f'{datapath}/StationXML')
os.makedirs(os.path.join(datapath, 'StationXML'))
domain = RectangularDomain(minlatitude=-85,
maxlatitude=-75,
minlongitude=160,
maxlongitude=-130)
restrictions = Restrictions(starttime=start,
endtime=stop,
chunklength_in_sec=86400,
network=network,
station=station,
location="*",
channel=channel,
reject_channels_with_gaps=True,
minimum_length=0.0,
minimum_interstation_distance_in_m=100.0)
mdl = MassDownloader(providers=["IRIS"])
mdl.download(
domain,
restrictions,
# mseed_storage=f"{datapath}/MSEED",
mseed_storage=os.path.join(datapath, 'MSEED'),
# stationxml_storage=f"{datapath}/StationXML"
stationxml_storage=os.path.join(datapath, 'StationXML'),
)
logger = logging.getLogger("obspy.clients.fdsn.mass_downloader")
logger.setLevel(logging.DEBUG)
def download(evtime,sec_before,sec_after,lon,lat,minrad,maxrad,provider=["IRIS"],OUT='./'):
'''
#example input
evtime='2000-01-01T06:58:39.780Z'
sec_before=120
sec_after=600
lon=120
lat=24
minrad=0
maxrad=10
provider=["IRIS"]
OUT='./TESTDL'
download(evtime,sec_before,sec_after,lon,lat,minrad,maxrad,provider,OUT)
'''
yyyy,mm,dd,HH,MM,SS,NS=cattime2normal(evtime)
origin_time = obspy.UTCDateTime(yyyy,mm,dd,HH,MM,SS,NS)
domain = CircularDomain(latitude=lat, longitude=lon,
minradius=minrad, maxradius=maxrad)
#domain = RectangularDomain(minlatitude=34.452, maxlatitude=38.72, minlongitude=-123.201, maxlongitude=-118.015)
restrictions = Restrictions(
# Get data from 5 minutes before the event to one hour after the
# event. This defines the temporal bounds of the waveform data.
starttime=origin_time - sec_before,
endtime=origin_time + sec_after,
# You might not want to deal with gaps in the data. If this setting is
# True, any trace with a gap/overlap will be discarded.
reject_channels_with_gaps=True,
# And you might only want waveforms that have data for at least 95 % of
# the requested time span. Any trace that is shorter than 95 % of the
# desired total duration will be discarded.
minimum_length=0.9,
# No two stations should be closer than 10 km to each other. This is
# useful to for example filter out stations that are part of different
# networks but at the same physical station. Settings this option to
# zero or None will disable that filtering.
minimum_interstation_distance_in_m=10E1,
# Only HH or BH channels. If a station has HH channels, those will be
# downloaded, otherwise the BH. Nothing will be downloaded if it has
# neither. You can add more/less patterns if you like.
#channel_priorities=["HH[ZNE]", "BH[ZNE]"],
#channel_priorities=["BH[ZNE]"],
#channel_priorities=["BH[ZNE]"],
#channel_priorities=["BHZ","HNZ"],
#channel_priorities=["BHZ"],
#channel_priorities=["HNZ"],
channel_priorities=["BHZ","HHZ"],
#channel_priorities=["HN[ZNE]"],
# Location codes are arbitrary and there is no rule as to which
# location is best. Same logic as for the previous setting.
location_priorities=["", "00", "10","100"])
# No specified providers will result in all known ones being queried.
#mdl = MassDownloader(providers=provider)
mdl = MassDownloader(providers=["IRIS"])
# The data will be downloaded to the ``./waveforms/`` and ``./stations/``
# folders with automatically chosen file names.
outstr=evtime.split('T')[0].replace('-','')+str(HH).zfill(2)+str(MM).zfill(2)+str(SS).zfill(2) #save dir as evid
outmsdir=OUT+'/'+outstr+"/waveforms"
outstadir=OUT+'/'+outstr+"/stations"
mdl.download(domain, restrictions,threads_per_client=20, mseed_storage=outmsdir,stationxml_storage=outstadir)
return(outmsdir,outstadir)
domain = GlobalDomain()
#stations_list=["AXAS1","AXAS2","AXBA1","AXCC1","AXEC1","AXEC2","AXEC3","AXID1"]
stations_list = "AX*"
client = Client(center)
### Restrictions
restrictions = Restrictions(
starttime=obspy.UTCDateTime(2015, 1, 1),
endtime=obspy.UTCDateTime(2016, 1, 1),
chunklength_in_sec=86400,
network=network_code,
station=stations_list,
# The typical use case for such a data set are noise correlations where
# gaps are dealt with at a later stage.
reject_channels_with_gaps=False,
# Same is true with the minimum length. All data might be useful.
minimum_length=0.0,
channel_priorities=["HH[ZNE]", "EH[ZNE]"],
# Guard against the same station having different names.
minimum_interstation_distance_in_m=0.0)
### Downlaod Data
mdl = MassDownloader(providers=[center])
mdl.download(domain,
restrictions,
mseed_storage="/home/baillard/waveforms/",
stationxml_storage='/home/baillard/')
#location_priorities=["", "00", "10"]
)
# No specified providers will result in all known ones being queried.
#client_gfz = Client("GFZ", user="******",password="******")
#-dnzc9DIzdWl-vMoejGxuWJJ
#-dnzc9DIzdWl-vMoejGxuWJJ:PVy8f6Xt-vXyV5vu
client_gfz = Client("GFZ",
user="******",
password="******")
#client_eth = Client("ETH", user="******", password="******")
mdl = MassDownloader(providers=[client_gfz, "IRIS"])
# The data will be downloaded to the ``./waveforms/`` and ``./stations/``
# folders with automatically chosen file names.
mdl.download(domain,
restrictions,
mseed_storage=eventid + "/waveforms",
stationxml_storage=eventid + "/stations")
###############################################transform the mseed into asdf using the pyasdf
import glob
import os
import pyasdf
if ts == True:
ds = pyasdf.ASDFDataSet("WITHFOCAL/" + eventid + ".h5",
compression="gzip-3")
ds.add_quakeml(eventid + ".ml")
event = ds.events[0]
files = glob.glob(eventid + "/waveforms/*.mseed")
for _i, filename in enumerate(files):
print("Adding file %i of %i ..." % (_i + 1, len(files)))
# Will not be used if the channel argument is used.
channel_priorities=('BH[ZNE12]', 'BL[ZNE12]', 'HH[ZNE12]',
'HL[ZNE12]', 'SH[ZNE12]', 'SL[ZNE12]',
'EH[ZNE12]', 'EL[ZNE12]', 'SP[ZNE12]',
'EP[ZNE12]', 'DP[ZNE12]'),
# Priority list for the locations.
# Will not be used if the location argument is used. (defaults are used)
location_priorities=('', '00', '10', '01', '20', '02', '30', '03',
'40', '04', '50', '05', '60', '06', '70',
'07', '80', '08', '90', '09'))
# Step 2: Storage Options
# Use custom function to store miniSEED waveforms
mseed_storage = get_mseed_storage
# Directly use folder name to store StationXML files
stationxml_storage = "stations"
# Step 3: Start the Download
# List of FDSN client names or service URLS
#mdl = MassDownloader(providers=["IRIS", "GFZ", "SCEDC"])
mdl = MassDownloader()
tt = mdl.download(domain,
restrictions,
threads_per_client=3,
mseed_storage=mseed_storage,
stationxml_storage=stationxml_storage)
locations = ['--']
if net_chan in [ 'WR.HN' ]:
channels = [ chan+'[ZNE]' ]
locations = ['']
if net_chan in [ 'GS.HN' ]:
channels = [ chan+'[Z12]' ]
locations = ['', '00', '20']
if net_chan in [ 'GM.HN' ]:
channels = [ chan+'[ZNE]' ]
locations = ['01']
# Restrictions for waveform query, this time use minimum length restriction
restrictions = Restrictions(starttime=UTCDateTime(ncss_origin['otime']) - tbefore,
endtime=UTCDateTime(ncss_origin['otime']) + tafter,
network=net,
channel_priorities=channels,
location_priorities=locations,
reject_channels_with_gaps=True,
minimum_length=min_length,
minimum_interstation_distance_in_m=1)
# Use massdownloader
mdl = MassDownloader(providers=[data_center])
try:
mdl.download(domain, restrictions, mseed_storage=raw_wf_data_dir,
stationxml_storage=sta_metadata_dir)
except:
print ('\n\n######### DOWNLOAD ERROR: moving on ##########\n\n')
starttime=starttime,
endtime=endtime,
network=network,
channel="BH?,SH?,LH?",
chunklength_in_sec=86400,
reject_channels_with_gaps=False,
minimum_length=0.0,
minimum_interstation_distance_in_m=50.0,
location_priorities=['', '00', '10', '01', '*'],
)
def mseed_storage(network, station, location, channel, starttime, endtime):
path = os.path.join(
DATADIR, starttime.strftime("%Y%m%d"),
"{}.{}.{}.{}.mseed".format(network, station, location, channel))
if os.path.exists(path):
return True
else:
return path
mdl = MassDownloader(providers=["IRIS"])
mdl.download(domain,
restrictions,
mseed_storage=mseed_storage,
stationxml_storage="stations",
threads_per_client=15)
# The typical use case for such a data set are noise correlations where
# gaps are dealt with at a later stage.
reject_channels_with_gaps=False,
# Same is true with the minimum length. All data might be useful.
minimum_length=0.0,
# Guard against the same station having different names.
#minimum_interstation_distance_in_m=100.0
)
mdl = "tmp"
download = False
if download:
mdl = MassDownloader(providers=["SCEDC"])
mdl.download(domain,
restrictions,
mseed_storage=data_path + "waveforms/USC/",
stationxml_storage=data_path + "stations/")
#%% Read in a couple test waveforms
plots = False
HNx_st = Stream()
LNx_st = Stream()
# High Broad Band (H??)
HNx_st += read(data_path + "waveforms/USC/*HN*.mseed")
# Long Period (L??)
LNx_st += read(data_path + "waveforms/USC/*LN*.mseed")
if plots:
HNx_st.plot()
def downloadwav(
phase: str, min_epid: float, max_epid: float, model: TauPyModel,
event_cat: Catalog, tz: float, ta: float, statloc: str,
rawloc: str, clients: list, evtfile: str, network: str = None,
station: str = None, saveasdf: bool = False,
log_fh: logging.FileHandler = None, loglvl: int = logging.WARNING,
verbose: bool = False, fast_redownload: bool = False):
"""
Downloads the waveforms for all events in the catalogue
for a circular domain around the epicentre with defined epicentral
distances from Clients defined in clients. Also Station
xmls for corresponding stations are downloaded.
Parameters
----------
phase : string
Arrival phase to be used. P, S, SKS, or ScS.
min_epid : float
Minimal epicentral distance to be downloaded.
max_epid : float
Maxmimal epicentral distance to be downloaded.
model : obspy.taup.TauPyModel
1D velocity model to calculate arrival.
event_cat : Obspy event catalog
Catalog containing all events, for which waveforms should be
downloaded.
tz : int
time window before first arrival to download (seconds)
ta : int
time window after first arrival to download (seconds)
statloc : string
Directory containing the station xmls.
rawloc : string
Directory containing the raw seismograms.
clients : list
List of FDSN servers. See obspy.Client documentation for acronyms.
network : string or list, optional
Network restrictions. Only download from these networks, wildcards
allowed. The default is None.
station : string or list, optional
Only allowed if network != None. Station restrictions.
Only download from these stations, wildcards are allowed.
The default is None.
saveasdf : bool, optional
Save the dataset as Adaptable Seismic Data Format (asdf; recommended).
Else, one will be left with .mseeds.
log_fh : logging.FileHandler, optional
file handler to be used for the massdownloader logger.
loglvl : int, optional
Use this logging level.
verbose: Bool, optional
Set True, when experiencing issues with download. Output of
obspy MassDownloader will be logged in download.log.
Returns
-------
None
"""
# needed to check whether data is already in the asdf
global asdfsave
asdfsave = saveasdf
# Calculate the min and max theoretical arrival time after event time
# according to minimum and maximum epicentral distance
min_time = model.get_travel_times(source_depth_in_km=500,
distance_in_degree=min_epid,
phase_list=[phase])[0].time
max_time = model.get_travel_times(source_depth_in_km=0.001,
distance_in_degree=max_epid,
phase_list=[phase])[0].time
mdl = MassDownloader(providers=clients)
###########
# logging for the download
fdsn_mass_logger = logging.getLogger("obspy.clients.fdsn.mass_downloader")
fdsn_mass_logger.setLevel(loglvl)
# # Create handler to the log
if log_fh is None:
fh = logging.FileHandler(os.path.join('logs', 'download.log'))
fh.setLevel(logging.INFO)
fh.setLevel(loglvl)
# Create Formatter
fmt = logging.Formatter(
fmt='%(asctime)s - %(levelname)s - %(message)s')
fh.setFormatter(fmt)
else:
fh = log_fh
fdsn_mass_logger.addHandler(fh)
####
# Loop over each event
global event
for ii, event in enumerate(tqdm(event_cat)):
# fetch event-data
origin_time = event.origins[0].time
ot_fiss = UTCDateTime(origin_time).format_fissures()
fdsn_mass_logger.info('Downloading event: '+ot_fiss)
evtlat = event.origins[0].latitude
evtlon = event.origins[0].longitude
# Download location
ot_loc = UTCDateTime(origin_time, precision=-1).format_fissures()[:-6]
evtlat_loc = str(roundhalf(evtlat))
evtlon_loc = str(roundhalf(evtlon))
tmp.folder = os.path.join(
rawloc, '%s_%s_%s' % (ot_loc, evtlat_loc, evtlon_loc))
# create folder for each event
os.makedirs(tmp.folder, exist_ok=True)
# Circular domain around the epicenter. This module also offers
# rectangular and global domains. More complex domains can be
# defined by inheriting from the Domain class.
domain = CircularDomain(latitude=evtlat, longitude=evtlon,
minradius=min_epid, maxradius=max_epid)
restrictions = Restrictions(
# Get data from sufficient time before earliest arrival
# and after the latest arrival
# Note: All the traces will still have the same length
starttime=origin_time + min_time - tz,
endtime=origin_time + max_time + ta,
network=network, station=station,
# You might not want to deal with gaps in the data.
# If this setting is
# True, any trace with a gap/overlap will be discarded.
# This will delete streams with several traces!
reject_channels_with_gaps=False,
# And you might only want waveforms that have data for at least 95%
# of the requested time span. Any trace that is shorter than 95% of
# the desired total duration will be discarded.
minimum_length=0.95, # For 1.00 it will always delete the waveform
# No two stations should be closer than 1 km to each other. This is
# useful to for example filter out stations that are part of
# different networks but at the same physical station. Settings
# this option to zero or None will disable that filtering.
# Guard against the same station having different names.
minimum_interstation_distance_in_m=100.0,
# Only HH or BH channels. If a station has BH channels, those will
# be downloaded, otherwise the HH. Nothing will be downloaded if it
# has neither.
channel_priorities=["BH[ZNE12]", "HH[ZNE12]"],
# Location codes are arbitrary and there is no rule as to which
# location is best. Same logic as for the previous setting.
# location_priorities=["", "00", "10"],
sanitize=False
# discards all mseeds for which no station information is available
# I changed it too False because else it will redownload over and
# over and slow down the script
)
# The data will be downloaded to the ``./waveforms/`` and
# ``./stations/`` folders with automatically chosen file names.
incomplete = True
while incomplete:
try:
mdl.download(
domain, restrictions,
mseed_storage=get_mseed_storage,
stationxml_storage=statloc,
threads_per_client=3, download_chunk_size_in_mb=50)
incomplete = False
except IncompleteRead:
continue # Just retry for poor connection
except Exception:
incomplete = False # Any other error: continue
# 2021.02.15 Here, we write everything to asdf
if saveasdf:
writeraw(event, tmp.folder, statloc, verbose, True)
# If that works, we will be deleting the cached mseeds here
try:
shutil.rmtree(tmp.folder)
except FileNotFoundError:
# This does not make much sense, but for some reason it occurs
# even if the folder exists? However, we will not want the
# whole process to stop because of this
pass
if fast_redownload:
event_cat[ii:].write(evtfile, format="QUAKEML")
if not saveasdf:
download_full_inventory(statloc, clients)
tmp.folder = "finished" # removes the restriction for preprocess.py
import obspy
from obspy.clients.fdsn.mass_downloader import RectangularDomain, Restrictions, MassDownloader
domain = RectangularDomain(minlatitude=-90,
maxlatitude=90,
minlongitude=-180,
maxlongitude=180.0)
restrictions = Restrictions(starttime=obspy.UTCDateTime(2012, 1, 1),
endtime=obspy.UTCDateTime(2014, 1, 1),
chunklength_in_sec=86400,
network="YT",
station="UPTW,DNTW,BEAR,THUR",
location="",
channel="BH*",
location_priorities=[
"01",
],
channel_priorities=["BHZ", "BHN", "BHE"],
reject_channels_with_gaps=False,
minimum_length=0.0)
mseed_storage = ("/media/Data/Data/YT/MSEED/raw/")
mdl = MassDownloader(providers=["IRIS"])
mdl.download(domain=domain,
restrictions=restrictions,
mseed_storage=mseed_storage,
stationxml_storage=("/media/Data/Data/YT/XML/"))
network=network,
# You might not want to deal with gaps in the data. If this setting is
# True, any trace with a gap/overlap will be discarded.
reject_channels_with_gaps=True,
# And you might only want waveforms that have data for at least 95 % of
# the requested time span. Any trace that is shorter than 95 % of the
# desired total duration will be discarded.
minimum_length=0.95,
# No two stations should be closer than 10 km to each other. This is
# useful to for example filter out stations that are part of different
# networks but at the same physical station. Settings this option to
# zero or None will disable that filtering.
minimum_interstation_distance_in_m=0,
# Only HH or BH channels. If a station has HH channels, those will be
# downloaded, otherwise the BH. Nothing will be downloaded if it has
# neither. You can add more/less patterns if you like.
channel_priorities=channel_priorities,
# channel_priorities=["HG[NE]", "HG[NE]"],
# Location codes are arbitrary and there is no rule as to which
# location is best. Same logic as for the previous setting.
location_priorities=["", "00", "10"])
# No specified providers will result in all known ones being queried.
# mdl = MassDownloader()
mdl = MassDownloader(providers=[providers])
# The data will be downloaded to the ``./waveforms/`` and ``./stations/`` # folders with automatically chosen file names.
mdl.download(domain,
restrictions,
mseed_storage=folder_output,
stationxml_storage=folder_output)
def download_rf(self, datadir, minDelta=30, maxDelta=150, fskip=1, chanrank=['BH', 'HH'], channels = 'ZNE', phase='P',\
startoffset=-30., endoffset=60.0, verbose=False, start_date=None, end_date=None, skipinv=True, threads_per_client = 3,\
providers = None, blon = 0.05, blat = 0.05):
"""request receiver function data from IRIS server
====================================================================================================================
::: input parameters :::
min/maxDelta - minimum/maximum epicentral distance, in degree
channels - Channel code, e.g. 'BHZ'.
Last character (i.e. component) can be a wildcard (‘?’ or ‘*’) to fetch Z, N and E component.
min/maxDelta - minimum/maximum epicentral distance, in degree
channel_rank - rank of channel types
phase - body wave phase to be downloaded, arrival time will be computed using taup
start/endoffset - start and end offset for downloaded data
=====================================================================================================================
"""
if providers is None:
providers = ['BGR', 'ETH', 'GFZ', 'ICGC', 'INGV', 'IPGP',\
'IRIS', 'KNMI', 'KOERI', 'LMU', 'NCEDC', 'NIEP', 'NOA', 'ODC', 'ORFEUS',\
'RASPISHAKE', 'RESIF', 'SCEDC', 'TEXNET', 'USP']
self.get_limits_lonlat()
minlongitude = self.minlon
maxlongitude = self.maxlon
if minlongitude > 180.:
minlongitude -= 360.
if maxlongitude > 180.:
maxlongitude -= 360.
lon0 = (minlongitude + maxlongitude) / 2.
lat0 = (self.minlat + self.maxlat) / 2.
domain = RectangularDomain(minlatitude=self.minlat - blat,
maxlatitude=self.maxlat + blat,
minlongitude=minlongitude - blon,
maxlongitude=maxlongitude + blon)
try:
print(self.cat)
except AttributeError:
self.copy_catalog()
try:
stime4down = obspy.core.utcdatetime.UTCDateTime(start_date)
except:
stime4down = obspy.UTCDateTime(0)
try:
etime4down = obspy.core.utcdatetime.UTCDateTime(end_date)
except:
etime4down = obspy.UTCDateTime()
mdl = MassDownloader(providers=providers)
chantype_list = []
for chantype in chanrank:
chantype_list.append('%s[%s]' % (chantype, channels))
channel_priorities = tuple(chantype_list)
t1 = time.time()
# loop over events
ievent = 0
for event in self.cat:
event_id = event.resource_id.id.split('=')[-1]
pmag = event.preferred_magnitude()
magnitude = pmag.mag
Mtype = pmag.magnitude_type
event_descrip = event.event_descriptions[
0].text + ', ' + event.event_descriptions[0].type
porigin = event.preferred_origin()
otime = porigin.time
if otime < stime4down or otime > etime4down:
continue
ievent += 1
try:
print('[%s] [DOWNLOAD BODY WAVE] ' %datetime.now().isoformat().split('.')[0] + \
'Event ' + str(ievent)+': '+ str(otime)+' '+ event_descrip+', '+Mtype+' = '+str(magnitude))
except:
print('[%s] [DOWNLOAD BODY WAVE] ' %datetime.now().isoformat().split('.')[0] + \
'Event ' + str(ievent)+': '+ str(otime)+' '+ event_descrip+', M = '+str(magnitude))
evlo = porigin.longitude
evla = porigin.latitude
try:
evdp = porigin.depth / 1000.
except:
continue
# log file existence
oyear = otime.year
omonth = otime.month
oday = otime.day
ohour = otime.hour
omin = otime.minute
osec = otime.second
label = '%d_%s_%d_%d_%d_%d' % (oyear, mondict[omonth], oday, ohour,
omin, osec)
eventdir = datadir + '/' + label
if fskip == 2 and os.path.isdir(eventdir):
continue
if not os.path.isdir(eventdir):
os.makedirs(eventdir)
event_logfname = eventdir + '/download.log'
if fskip == 1 and os.path.isfile(event_logfname):
continue
stationxml_storage = "%s/{network}/{station}.xml" % eventdir
# loop over stations
Nsta = 0
for network in self.inv:
for station in network:
netcode = network.code
stacode = station.code
staid = netcode + '.' + stacode
with warnings.catch_warnings():
warnings.simplefilter("ignore")
st_date = station.start_date
ed_date = station.end_date
if skipinv and (otime < st_date or otime > ed_date):
continue
stlo = station.longitude
stla = station.latitude
dist, az, baz = obspy.geodetics.gps2dist_azimuth(
evla, evlo, stla, stlo) # distance is in m
dist = dist / 1000.
if baz < 0.:
baz += 360.
Delta = obspy.geodetics.kilometer2degrees(dist)
if Delta < minDelta:
continue
if Delta > maxDelta:
continue
arrivals = taupmodel.get_travel_times(
source_depth_in_km=evdp,
distance_in_degree=Delta,
phase_list=[phase]) #, receiver_depth_in_km=0)
try:
arr = arrivals[0]
arrival_time = arr.time
rayparam = arr.ray_param_sec_degree
except IndexError:
continue
starttime = otime + arrival_time + startoffset
endtime = otime + arrival_time + endoffset
restrictions = Restrictions(
network=netcode,
station=stacode,
# starttime and endtime
starttime=starttime,
endtime=endtime,
# You might not want to deal with gaps in the data.
reject_channels_with_gaps=True,
# And you might only want waveforms that have data for at least
# 95 % of the requested time span.
minimum_length=0.95,
# No two stations should be closer than 10 km to each other.
minimum_interstation_distance_in_m=10E3,
channel_priorities=channel_priorities,
sanitize=True)
mseed_storage = eventdir
try:
mdl.download(domain,
restrictions,
mseed_storage=mseed_storage,
stationxml_storage=stationxml_storage,
threads_per_client=threads_per_client)
except Exception:
continue
Nsta += 1
print('--- [DOWNLOAD BODY WAVE] Event: %s %s' %
(otime.isoformat(), event_descrip))
with open(event_logfname, 'w') as fid:
fid.writelines('evlo: %g, evla: %g\n' % (evlo, evla))
fid.writelines('DONE\n')
return
def data_request(cmt_filename, param_path):
# Request config_file
request_param_path = os.path.join(param_path,
"RequestParams/RequestParams.yml")
# Read the parameter file
rCparams = smart_read_yaml(request_param_path, mpi_mode=is_mpi_env())
# Earthquake and Station parameters
cmt_dir = os.path.dirname(cmt_filename)
station_dir = os.path.join(cmt_dir, "station_data")
# Get STATIONS file from CMT directory
stationsfile = os.path.join(station_dir, "STATIONS")
# Observed output dir
obsd_dir = os.path.join(cmt_dir, "seismograms", "obs")
# CMT parameter input
cmt = CMTSource.from_CMTSOLUTION_file(cmt_filename)
duration = rCparams['duration']
starttime_offset = rCparams['starttime_offset']
starttime = cmt.origin_time + starttime_offset
endtime = starttime + duration
# Get station_list from station_file in database entry
stations = read_station_file(stationsfile)
# Create list of networks to download from
networks = list(set([station[0] for station in stations]))
network_string = ",".join(networks)
# Set domain containing all locations
# Rectangular domain containing parts of southern Germany.
domain = RectangularDomain(minlatitude=-90,
maxlatitude=90,
minlongitude=-180,
maxlongitude=180)
# Set download restrictions
restrictions = Restrictions(
starttime=starttime,
endtime=endtime,
reject_channels_with_gaps=False,
minimum_length=float(rCparams['minimum_length']),
# Trace needs to be almost full length
network=network_string, # Only certain networks
channel=",".join(rCparams['channels']),
location=",".join(rCparams['locations']))
# No specified providers will result in all known ones being queried.
providers = ["IRIS"]
mdl = MassDownloader(providers=providers)
# The data will be downloaded to the ``./waveforms/`` and ``./stations/``
# folders with automatically chosen file n
stationxml_storage = os.path.join(station_dir)
waveform_storage = os.path.join(obsd_dir)
logger.info("MSEEDs: %s" % waveform_storage)
logger.info("XMLs: %s" % stationxml_storage)
mdl.download(domain,
restrictions,
mseed_storage=waveform_storage,
stationxml_storage=stationxml_storage)
def download_surf(self, datadir, commontime = True, fskip=True, chanrank=['LH', 'BH', 'HH'],\
channels='ZNE', vmax = 8.0, vmin=.5, verbose=False, start_date=None, end_date=None, skipinv=True, threads_per_client = 3,\
providers = None, blon = 0.05, blat = 0.05):
"""request Rayleigh wave data from
====================================================================================================================
::: input parameters :::
lon0, lat0 - center of array. If specified, all waveform will have the same starttime and endtime
min/maxDelta - minimum/maximum epicentral distance, in degree
channel - Channel code, e.g. 'BHZ'.
Last character (i.e. component) can be a wildcard (‘?’ or ‘*’) to fetch Z, N and E component.
vmin, vmax - minimum/maximum velocity for surface wave window
=====================================================================================================================
"""
if providers is None:
providers = ['BGR', 'ETH', 'GFZ', 'ICGC', 'INGV', 'IPGP',\
'IRIS', 'KNMI', 'KOERI', 'LMU', 'NCEDC', 'NIEP', 'NOA', 'ODC', 'ORFEUS',\
'RASPISHAKE', 'RESIF', 'SCEDC', 'TEXNET', 'USP']
self.get_limits_lonlat()
minlongitude = self.minlon
maxlongitude = self.maxlon
if minlongitude > 180.:
minlongitude -= 360.
if maxlongitude > 180.:
maxlongitude -= 360.
lon0 = (minlongitude + maxlongitude) / 2.
lat0 = (self.minlat + self.maxlat) / 2.
domain = RectangularDomain(minlatitude=self.minlat - blat,
maxlatitude=self.maxlat + blat,
minlongitude=minlongitude - blon,
maxlongitude=maxlongitude + blon)
try:
print(self.cat)
except AttributeError:
self.copy_catalog()
try:
stime4down = obspy.core.utcdatetime.UTCDateTime(start_date)
except:
stime4down = obspy.UTCDateTime(0)
try:
etime4down = obspy.core.utcdatetime.UTCDateTime(end_date)
except:
etime4down = obspy.UTCDateTime()
mdl = MassDownloader(providers=providers)
chantype_list = []
for chantype in chanrank:
chantype_list.append('%s[%s]' % (chantype, channels))
channel_priorities = tuple(chantype_list)
t1 = time.time()
# loop over events
for event in self.cat:
pmag = event.preferred_magnitude()
try:
magnitude = pmag.mag
evdp = porigin.depth / 1000.
except:
pass
try:
Mtype = pmag.magnitude_type
event_descrip = event.event_descriptions[
0].text + ', ' + event.event_descriptions[0].type
porigin = event.preferred_origin()
otime = porigin.time
timestr = otime.isoformat()
evlo = porigin.longitude
evla = porigin.latitude
except:
pass
if otime < stime4down or otime > etime4down:
continue
if commontime:
dist, az, baz = obspy.geodetics.gps2dist_azimuth(
evla, evlo, lat0, lon0) # distance is in m
dist = dist / 1000.
starttime = otime + dist / vmax
endtime = otime + dist / vmin
oyear = otime.year
omonth = otime.month
oday = otime.day
ohour = otime.hour
omin = otime.minute
osec = otime.second
label = '%d_%s_%d_%d_%d_%d' % (oyear, mondict[omonth], oday, ohour,
omin, osec)
eventdir = datadir + '/' + label
if not os.path.isdir(eventdir):
os.makedirs(eventdir)
event_logfname = eventdir + '/download.log'
if fskip and os.path.isfile(event_logfname):
continue
stationxml_storage = "%s/{network}/{station}.xml" % eventdir
if commontime:
restrictions = Restrictions(
# starttime and endtime
starttime=starttime,
endtime=endtime,
# You might not want to deal with gaps in the data.
reject_channels_with_gaps=True,
# And you might only want waveforms that have data for at least
# 95 % of the requested time span.
minimum_length=0.95,
# No two stations should be closer than 10 km to each other.
minimum_interstation_distance_in_m=10E3,
# Only HH or BH channels. If a station has HH channels,
# those will be downloaded, otherwise the BH. Nothing will be
# downloaded if it has neither.
channel_priorities=channel_priorities,
sanitize=True)
mseed_storage = eventdir
# # # mseed_storage = ("%s/{network}/{station}/{channel}.{location}.%s.mseed" %(datadir, label) )
mdl.download(domain,
restrictions,
mseed_storage=mseed_storage,
stationxml_storage=stationxml_storage,
threads_per_client=threads_per_client)
else:
# loop over stations
Nsta = 0
for network in self.inv:
for station in network:
netcode = network.code
stacode = station.code
staid = netcode + '.' + stacode
with warnings.catch_warnings():
warnings.simplefilter("ignore")
st_date = station.start_date
ed_date = station.end_date
if skipinv and (otime < st_date or otime > ed_date):
continue
stlo = station.longitude
stla = station.latitude
dist, az, baz = obspy.geodetics.gps2dist_azimuth(
evla, evlo, stla, stlo) # distance is in m
dist = dist / 1000.
starttime = otime + dist / vmax
endtime = otime + dist / vmin
restrictions = Restrictions(
network=netcode,
station=stacode,
# starttime and endtime
starttime=starttime,
endtime=endtime,
# You might not want to deal with gaps in the data.
reject_channels_with_gaps=True,
# And you might only want waveforms that have data for at least
# 95 % of the requested time span.
minimum_length=0.95,
# No two stations should be closer than 10 km to each other.
minimum_interstation_distance_in_m=10E3,
# Only HH or BH channels. If a station has HH channels,
# those will be downloaded, otherwise the BH. Nothing will be
# downloaded if it has neither.
channel_priorities=channel_priorities,
sanitize=True)
mseed_storage = eventdir
# mseed_storage = ("%s/{network}/{station}/{channel}.{location}.%s.mseed" %(datadir, label) )
mdl.download(domain,
restrictions,
mseed_storage=mseed_storage,
stationxml_storage=stationxml_storage,
threads_per_client=threads_per_client)
Nsta += 1
print('--- [RAYLEIGH DATA DOWNLOAD] Event: %s %s' %
(otime.isoformat(), event_descrip))
with open(event_logfname, 'w') as fid:
fid.writelines('evlo: %g, evla: %g\n' % (evlo, evla))
if commontime:
fid.writelines('distance: %g km\n' % dist)
fid.writelines('DONE\n')
return
def GetData(self,stationdirpath='stations',datadirpath='waveforms',req_type='continuous',\
chunklength=86400,tracelen=20000, vmodel='ak135'):
'''Call obspy mass downloader to get waveform data. Chunklength refers to the trace length option
for a continuous download, tracelen is for an event-based request'''
#Currently set up to download one day worth of data in the continuous mode, 2000 seconds
#in the event-based mode
self.stationdirpath = stationdirpath
self.datadirpath = datadirpath
from obspy.clients.fdsn.mass_downloader import RectangularDomain, CircularDomain,\
Restrictions, MassDownloader
if req_type == 'continuous':
#Get data from all stations within this domain
domain = RectangularDomain(minlatitude=self.minlatitude,maxlatitude=self.maxlatitude,\
minlongitude=self.minlongitude,maxlongitude=self.maxlongitude)
#Download data in daily segements - may want to change
restrictions = Restrictions(\
starttime=self.starttime,endtime=self.endtime,\
chunklength_in_sec=chunklength,\
channel=self.channel,station=self.station,location="",\
reject_channels_with_gaps=False,\
minimum_length=0.0,minimum_interstation_distance_in_m=100.0)
#Call mass downloader to get the waveform information
mdl = MassDownloader(providers=[self.clientname])
mdl.download(domain,
restrictions,
mseed_storage=datadirpath,
stationxml_storage=stationdirpath)
elif req_type == 'event':
if self.quake_cat == None:
print(
"Stop: Must call fetchEvents first to get event catalog to download from"
)
sys.exit(1)
#Add option for non-continuous download - event/station pairing for example
#Ger data for all stations in this domain
domain = RectangularDomain(minlatitude=self.minlatitude,maxlatitude=self.maxlatitude,\
minlongitude=self.minlongitude,maxlongitude=self.maxlongitude)
for event in self.quake_cat:
cnt = 0.
print("Downloading data for event %s" % event)
#For each event, download the waveforms at all stations requested
origin_time = event.origins[0].time
vel_model = TauPyModel(model=vmodel)
#case where we only want to download data for some station-event pairs'
stations_to_exclude = []
if self.station_autoselect_flag == True:
stations_to_download = []
evlat = event.origins[0].latitude
evlon = event.origins[0].longitude
#EK changes added 04/2019
evdep = event.origins[0].depth
for network in self.inventory:
for station in network:
stlat = station.latitude
stlon = station.longitude
#EK 04/2019
#this downloads data within Short Wave Window (SWW), a cone under the station bounded by an angle, here we chose 45 deg
#calculate distance between eq and station and azimuth
ddeg = locations2degrees(evlat, evlon, stlat,
stlon)
distance_m, az, baz = gps2dist_azimuth(
evlat, evlon, stlat, stlon)
#calculate proxy for incident angle
theta = np.arctan2(distance_m, evdep)
if theta <= np.pi / 4:
#find if station has needed arrival
arrivals = vel_model.get_travel_times(
source_depth_in_km=evdep / 1000.,
distance_in_degree=ddeg,
phase_list=["s", "S"])
if len(arrivals) > 0:
#get stations you want to download
stations_to_download.append(station.code)
print(station.code,
'angle = %.2f' % np.rad2deg(theta))
print(arrivals)
cnt = cnt + 1
else:
stations_to_exclude.append(station.code)
else:
if station.code not in stations_to_exclude:
stations_to_exclude.append(station.code)
print(
"\n-------------\n%g event-station pairs found in SWW\n-------------\n"
% cnt)
print(
"\n-------------\nSelecting just the following stations for download\n-------------\n"
)
print(stations_to_download)
#this approach doesn't work, use exclude_stations flag later
#restrictions = Restrictions(starttime=origin_time,endtime=origin_time + tracelen,\
#reject_channels_with_gaps=False, minimum_length=0.95, minimum_interstation_distance_in_m=10E3,\
#channel=self.channel,location="",network=self.network,station=stations_to_download)
#case where we have single network
if self.network:
restrictions = Restrictions(starttime=origin_time,endtime=origin_time + tracelen,\
reject_channels_with_gaps=False, minimum_length=0.95, minimum_interstation_distance_in_m=10E3,\
channel=self.channel,location="",network=self.network,exclude_stations=stations_to_exclude)
#Case where we want all networks within a region (assumes that we also want all stations unless we have built
# a stations to exclude list)
else:
restrictions = Restrictions(starttime=origin_time,endtime=origin_time + tracelen,\
reject_channels_with_gaps=False, minimum_length=0.95, minimum_interstation_distance_in_m=10E3,\
channel=self.channel,exclude_stations=stations_to_exclude)
mdl = MassDownloader(providers=[self.clientname])
mdl.download(domain, restrictions, mseed_storage=datadirpath,\
stationxml_storage=stationdirpath)
def retrieveData(self):
"""Retrieve data from many FDSN services, turn into StreamCollection.
Args:
event (dict):
Best dictionary matching input event, fields as above
in return of getMatchingEvents().
Returns:
StreamCollection: StreamCollection object.
"""
rawdir = self.rawdir
if self.rawdir is None:
rawdir = tempfile.mkdtemp()
else:
if not os.path.isdir(rawdir):
os.makedirs(rawdir)
# use the mass downloader to retrieve data of interest from any FSDN
# service.
origin_time = UTCDateTime(self.time)
# The Obspy mass downloader has it's own logger - grab that stream
# and write it to our own log file
ldict = logging.Logger.manager.loggerDict
if OBSPY_LOGGER in ldict:
root = logging.getLogger()
fhandler = root.handlers[0]
obspy_logger = logging.getLogger(OBSPY_LOGGER)
obspy_stream_handler = obspy_logger.handlers[0]
obspy_logger.removeHandler(obspy_stream_handler)
obspy_logger.addHandler(fhandler)
# Circular domain around the epicenter.
domain = CircularDomain(latitude=self.lat, longitude=self.lon,
minradius=0, maxradius=self.radius)
restrictions = Restrictions(
# Define the temporal bounds of the waveform data.
starttime=origin_time - self.time_before,
endtime=origin_time + self.time_after,
network=self.network, station='*',
location='*',
location_priorities=['*'],
reject_channels_with_gaps=self.reject_channels_with_gaps,
# Any trace that is shorter than 95 % of the
# desired total duration will be discarded.
minimum_length=self.minimum_length,
sanitize=self.sanitize,
minimum_interstation_distance_in_m=self.minimum_interstation_distance_in_m,
exclude_networks=self.exclude_networks,
exclude_stations=self.exclude_stations,
channel_priorities=self.channels)
# DEBUGGING
pp = pprint.PrettyPrinter()
pp.pprint(domain.__dict__)
print('***************************')
pp.pprint(restrictions.__dict__)
# DEBUGGING
# No specified providers will result in all known ones being queried.
mdl = MassDownloader()
# we can have a problem of file overlap, so let's remove existing
# mseed files from the raw directory.
logging.info('Deleting old MiniSEED files...')
delete_old_files(rawdir, '*.mseed')
# remove existing png files as well
logging.info('Deleting old PNG files...')
delete_old_files(rawdir, '*.png')
# remove existing xml files as well
logging.info('Deleting old XML files...')
delete_old_files(rawdir, '*.xml')
logging.info('Downloading new MiniSEED files...')
# The data will be downloaded to the ``./waveforms/`` and ``./stations/``
# folders with automatically chosen file names.
mdl.download(domain, restrictions, mseed_storage=rawdir,
stationxml_storage=rawdir)
seed_files = glob.glob(os.path.join(rawdir, '*.mseed'))
streams = []
for seed_file in seed_files:
tstreams = read_fdsn(seed_file)
streams += tstreams
stream_collection = StreamCollection(streams=streams,
drop_non_free=self.drop_non_free)
return stream_collection