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 __init__(self, network, station, location, channel, starttime, endtime, chunklength_in_sec=None, overlap_in_sec=0, groupby='{network}.{station}.{channel}'): """ Restrictions to download mseed Parameters: ----------- network: str Select one or more network codes. Multiple codes are comma-separated (e.g. "IU,TA"). Wildcards are allowed. station: str Select one or more SEED station codes. Multiple codes are comma-separated (e.g. "ANMO,PFO"). Wildcards are allowed. location: str Select one or more SEED location identifiers. Multiple identifiers are comma-separated (e.g. "00,01"). Wildcards are allowed. channel: str Select one or more SEED channel codes. Multiple codes are comma-separated (e.g. "BHZ,HHZ"). starttime: obspy.UTCDateTime Limit results to time series samples on or after the specified start time. endtime: obspy.UTCDateTime Limit results to time series samples on or before the specified end time. chunklength_in_sec: None or int The length of one chunk in seconds. If set, the time between starttime and endtime will be divided into segments of chunklength_in_sec seconds. overlap_in_sec: None or int For more than one chunk, each segment will have overlapping seconds groupby: str Download group traces together which have the same metadata given by this parameter. The parameter should name the corresponding keys of the stats object, e.g. '{network}.{station}'. This parameter can take the value 'id' which groups the traces by SEED id. """ Restrictions.__init__(self, network=network, station=station, location=location, channel=channel, starttime=starttime, endtime=endtime, chunklength_in_sec=chunklength_in_sec) self.overlap_in_sec = overlap_in_sec self.groupby = groupby
def _download_kemmerer(self): """ downloads both stations and waveforms """ for station in ["M17A", "M18A"]: domain = RectangularDomain( minlatitude=40.0, maxlatitude=43.0, minlongitude=-111.0, maxlongitude=-110.0, ) restrictions = Restrictions( starttime=obspy.UTCDateTime("2009-04-01T00:00:00"), endtime=obspy.UTCDateTime("2009-04-04T00:00:00"), chunklength_in_sec=3600, network="TA", channel="BH?", station=station, reject_channels_with_gaps=False, minimum_length=0.0, minimum_interstation_distance_in_m=10.0, ) MassDownloader(providers=[self._download_client]).download( domain, restrictions, mseed_storage=str(self.waveform_path), stationxml_storage=str(self.station_path), )
def _download_crandall(self): """download waveform/station info for dataset.""" bank = WaveBank(self.waveform_path) domain = CircularDomain( self.latitude, self.longitude, minradius=0, maxradius=kilometers2degrees(self.max_dist), ) cat = obspy.read_events(str(self.source_path / "events.xml")) df = events_to_df(cat) for _, row in df.iterrows(): starttime = row.time - self.time_before endtime = row.time + self.time_after restrictions = Restrictions( starttime=UTC(starttime), endtime=UTC(endtime), minimum_length=0.90, minimum_interstation_distance_in_m=100, channel_priorities=["HH[ZNE]", "BH[ZNE]"], location_priorities=["", "00", "01", "--"], ) kwargs = dict( domain=domain, restrictions=restrictions, mseed_storage=str(self.waveform_path), stationxml_storage=str(self.station_path), ) MassDownloader(providers=[self._download_client]).download( **kwargs) # ensure data have actually been downloaded bank.update_index() assert not bank.read_index(starttime=starttime, endtime=endtime).empty
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_noise_windows(yr=2021, mnth=3, day=4, tod='morning'): morning = [UTCDateTime(yr, mnth, day, 6), UTCDateTime(yr, mnth, day, 9)] afternoon = [ UTCDateTime(yr, mnth, day, 12), UTCDateTime(yr, mnth, day, 15) ] evening = [UTCDateTime(yr, mnth, day, 18), UTCDateTime(yr, mnth, day, 21)] night = [ UTCDateTime(yr, mnth, day, 22, 30), UTCDateTime(yr, mnth, day + 1, 1, 30) ] restrictions = Restrictions( starttime=morning[0], endtime=morning[1], chunklength_in_sec=46, network=ntwk_query[2], station="USC", location="", channel="?N?", reject_channels_with_gaps=False, minimum_length=0.0, )
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 _get_w(bg, st, station_dic, end_t, mdl, domain, output_dir, n_days, channel_list): next_month = bg + datetime.timedelta(n_days) nt = station_dic[str(st)]['network'] save_dir = os.path.join(output_dir, st) save_dir2 = os.path.join(output_dir + "xml", st) while next_month <= end_t: if len(channel_list) == 0: restrictions = Restrictions(starttime=bg, endtime=next_month, network=nt, station=st, reject_channels_with_gaps=False, minimum_length=0.0) else: restrictions = Restrictions(starttime=bg, endtime=next_month, network=nt, station=st, reject_channels_with_gaps=False, channel_priorities=channel_list, minimum_length=0.0) try: mdl.download(domain, restrictions, mseed_storage=save_dir, stationxml_storage=save_dir2) print(f"** done with --> {st} -- {nt} -- {str(bg).split('T')[0]}") except Exception: print(f"!! failed downloading --> {st} -- {nt} !") pass time.sleep(np.random.randint(25, 30)) bg = next_month next_month = bg + datetime.timedelta(n_days)
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 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_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 _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_event(event: str): d.mkdir(mseed := f'mseed/{event}') d.mkdir(xml := f'xml/{event}') # Event object e = read_events(f'events/{event}')[0] time = e.preferred_origin().time # call mass downloader restrictions = Restrictions( starttime=time - 600, endtime=time + 7800, reject_channels_with_gaps=True, minimum_length=0.95, channel_priorities=['BH[ZNE12]', 'HH[ZNE12]'], location_priorities=['', '00', '10'] ) MassDownloader().download( GlobalDomain(), restrictions, mseed_storage=d.abs(mseed), stationxml_storage=d.abs(xml) )
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 generate_restrictions( self, starttime: obspy.core.utcdatetime.UTCDateTime, endtime: obspy.core.utcdatetime.UTCDateTime, ds: dict, ): """ Create a restriction criterion for the mass downloader :param starttime: Start time of data request :type starttime: obspy.core.utcdatetime.UTCDateTime :param endtime: End time of data request :type endtime: obspy.core.utcdatetime.UTCDateTime :param ds: Dictionary of information :type ds: dict :return: Restrictions to download request """ from obspy.clients.fdsn.mass_downloader import Restrictions return Restrictions( starttime=starttime, endtime=endtime, # Go back 1 day. station_starttime=starttime - 86400 * 1, # Advance 1 day. station_endtime=endtime + 86400 * 1, network=ds["networks"], 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"], )
maxradius=r) t1 = UTCDateTime(2021, 3, 2) t2 = UTCDateTime(2021, 3, 5) restrictions = Restrictions( # Get data for a whole year. starttime=t1, endtime=t2, # 1 day chunks chunklength_in_sec=86400, # 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=ntwk_query[2], station="USC", location="", channel="?N?", # 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:
minlatitude=statLat_min, maxlatitude=statLat_max) 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 - seconds_before, endtime=origin_time + seconds_after, # station = 'BGAR', 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.
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
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 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 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)
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)
starttime = UTCDateTime(2008, 1, 1) endtime = UTCDateTime(2011, 1, 1) ROOTDIR = "/run/media/seisman/Seagate Expansion Drive/DOWNLOADING/" DATADIR = ROOTDIR + network domain = RectangularDomain(minlatitude=18, maxlatitude=54, minlongitude=65, maxlongitude=135) restrictions = Restrictions( 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
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
center = "IRIS" 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/')
domain = RectangularDomain(minlatitude=52., maxlatitude=72.5, minlongitude=-172., maxlongitude=-122.) restrictions = Restrictions( # Get data for a whole year. starttime=obspy.UTCDateTime(2017, 6, 11), endtime=obspy.UTCDateTime(2017, 6, 21), # 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="TA", station="H20K", location="", channel="LH?", # 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) mseed_storage = ("waveforms/{network}/{station}/" "{channel}.{location}.{starttime}.{endtime}.mseed") stationxml_storage = "stations/{network}/{station}.xml" # Restrict the number of providers if you know which serve the desired