def buildStationList(net, sta, cha, t, resp): '''This will build a list of stations for a given network. ex: staList = buildStationList("IU","*","BH*",eventTime,True) for resp info ex: staList = buildStationList("IU","*","BH*",eventTime,False) w/o resp info ''' from obspy.clients.fdsn import Client from obspy import UTCDateTime client = Client("IRIS") # set some event info # this is a deep earthquake in bolivia #t = UTCDateTime("2017-02-21T14:09:04") if resp: inventory = client.get_stations(network="IU", station="*", starttime=t, channel="BH*", level="response") else: inventory = client.get_stations(network="IU", station="*", starttime=t) # to plot up all the stations... #inventory.plot() # to get the station coordinates #station_coordinates = [] #for network in inventory: # for station in network: # station_coordinates.append((network.code, station.code, station.latitude, station.longitude, station.elevation)) return inventory
def download(self, s): client = Client("IRIS") starttime = obspy.UTCDateTime("2010-01-01") endtime = obspy.UTCDateTime("2015-01-02") # for s in stations: # Try and download, don't worry if no data is available. try: stream = client.get_stations(network=s.net, station=s.sta, starttime=starttime, endtime=endtime, level="channel") fname = os.path.join("STATION_XML_META", "station.{}_{}.meta.xml".format(s.net, s.sta)) stream.write(fname, format='STATIONXML') except Exception as e: print e pass try: stream = client.get_stations(network=s.net, station=s.sta, starttime=starttime, endtime=endtime, level="response") fname = os.path.join( "STATION_XML_META", "station.{}_{}.response.xml".format(s.net, s.sta)) stream.write(fname, format='STATIONXML') print 'Finished downloading {}.{}'.format(s.net, s.sta) except Exception as e: print e pass
def test_level_argument(self): client = FDSNClient(self.live_server_url) inv = client.get_stations(level="channel") c = inv.get_contents() self.assertEqual(len(c["networks"]), 1) self.assertEqual(len(c["stations"]), 1) self.assertEqual(len(c["channels"]), 3) inv = client.get_stations(level="station") c = inv.get_contents() self.assertEqual(len(c["networks"]), 1) self.assertEqual(len(c["stations"]), 1) self.assertEqual(len(c["channels"]), 0) inv = client.get_stations(level="network") c = inv.get_contents() self.assertEqual(len(c["networks"]), 1) self.assertEqual(len(c["stations"]), 0) self.assertEqual(len(c["channels"]), 0) inv = client.get_stations(level="response") c = inv.get_contents() self.assertEqual(len(c["networks"]), 1) self.assertEqual(len(c["stations"]), 1) self.assertEqual(len(c["channels"]), 3) for channel in inv[0][0]: self.assertIsNotNone(channel.response)
def download(self, s): client = Client("IRIS") starttime = obspy.UTCDateTime("2010-01-01") endtime = obspy.UTCDateTime("2015-01-02") # for s in stations: # Try and download, don't worry if no data is available. try: stream = client.get_stations(network=s.net, station=s.sta, starttime=starttime, endtime=endtime, level="channel") fname = os.path.join("STATION_XML_META", "station.{}_{}.meta.xml".format(s.net, s.sta)) stream.write(fname, format='STATIONXML') except Exception as e: print e pass try: stream = client.get_stations(network=s.net, station=s.sta, starttime=starttime, endtime=endtime, level="response") fname = os.path.join("STATION_XML_META", "station.{}_{}.response.xml".format(s.net, s.sta)) stream.write(fname, format='STATIONXML') print 'Finished downloading {}.{}'.format(s.net, s.sta) except Exception as e: print e pass
def check_stations_network(net, Year, Month, Day, Hour, Minute, Second): # find stations with data start_1 = (str(Year) + '-' + str(Month) + '-' + str(Day) + '-' + str(Hour) + '-' + str(Minute) + '-' + str(Second)) t0 = UTCDateTime(start_1) client = Client('IRIS') inv = client.get_stations(network=net, level="station") network = inv[0] netstat = [] for i in range(len(network)): netstat.extend([net + "." + network[i].code]) print(color.GREEN + 'data is available for these stations:' + str(netstat) + color.END) # now get metadata endtime = t0 + 30 inv = client.get_stations(network=net, station="*", location="*", channel="HHZ", starttime=t0, endtime=endtime, level="response") return netstat, t0, inv
def geonet_north_island(level="station"): """ Return geonet broadband stations in an obspy network :type level: str :param level: level to propogate network creation :rtype: obspy.core.inventory.network.Network """ c = Client("GEONET") # Extended North Island coverage, Kaikoura to East Cape lat_min = -42.8 lat_max = -37.1 lon_min = 173 lon_max = 179.4 starttime = UTCDateTime("2000-01-01") # GeoNet Broadband instruments with standard station code Z inv_geonet = c.get_stations(network="NZ", station="*Z", channel="HH?", minlatitude=lat_min, maxlatitude=lat_max, minlongitude=lon_min, maxlongitude=lon_max, level=level, starttime=starttime, endtime=UTCDateTime()) inv_hold = c.get_stations(network="NZ", station="*Z", channel="BH?", minlatitude=lat_min, maxlatitude=lat_max, minlongitude=lon_min, maxlongitude=lon_max, level=level, starttime=starttime, endtime=UTCDateTime()) inv_geonet = merge_inventories(inv_geonet, inv_hold) # Stations with unique names (Wellington and Baring Head) for station in ["WEL", "BHW"]: inv_hold = c.get_stations(network="NZ", station=station, channel="HH?", minlatitude=lat_min, maxlatitude=lat_max, minlongitude=lon_min, maxlongitude=lon_max, level=level, starttime=starttime, endtime=UTCDateTime()) inv_geonet = merge_inventories(inv_geonet, inv_hold) return inv_geonet[0]
def test_rectangular_geo_queries(self): client = FDSNClient(self.live_server_url) # lat = 48.995167 # lon = 11.519922 # This works. self.assertEqual( len(client.get_stations( minlatitude=48, maxlatitude=49, minlongitude=11, maxlongitude=12).get_contents()["stations"]), 1) # Make sure one border does not include the point at a time. with self.assertRaises(FDSNException): client.get_stations(minlatitude=48.996, maxlatitude=49, minlongitude=11, maxlongitude=12) with self.assertRaises(FDSNException): client.get_stations(minlatitude=48, maxlatitude=48.5, minlongitude=11, maxlongitude=12) with self.assertRaises(FDSNException): client.get_stations(minlatitude=48, maxlatitude=49, minlongitude=11.6, maxlongitude=12) with self.assertRaises(FDSNException): client.get_stations(minlatitude=48, maxlatitude=49, minlongitude=11, maxlongitude=11.4)
def get_stnxml(self, network='*', station="*", channel="BHZ,BHE,BHN"): print("\n") self.logger.info('Retrieving station information') ninvt = 0 while ninvt < len(self.client): try: client = Client(self.client[ninvt]) except Exception as e: self.logger.error( f"No FDSN services could be discovered for {self.client[ninvt]}! Try again after some time." ) sys.exit() self.logger.info(f'from {self.client[ninvt]}') try: invt = client.get_stations(network=network, station=station, channel=self.channel, level='channel', minlongitude=self.minlongitude, maxlongitude=self.maxlongitude, minlatitude=self.minlatitude, maxlatitude=self.maxlatitude) inventory = invt break except Exception as exception: self.logger.error( f"No stations found for the given parameters for {self.client[ninvt]}", exc_info=True) ninvt += 1 # sys.exit() if len(self.client) > 1: for cl in self.client[ninvt + 1:]: self.logger.info(f'from {cl}') try: client = Client(cl) invt = client.get_stations(network=network, station=station, channel=self.channel, level='channel', minlongitude=self.minlongitude, maxlongitude=self.maxlongitude, minlatitude=self.minlatitude, maxlatitude=self.maxlatitude) inventory += invt except Exception as exception: self.logger.warning(f"FDSNNoDataException for {cl}") # self.logger.info(inventory) inventory.write(self.inventoryfile, 'STATIONXML') self.inv = inventory inventory.write(self.inventorytxtfile, 'STATIONTXT', level='station') organize_inventory(self.inventorytxtfile)
def get_station_coordinates(self, client_base_url='IRIS'): """ get_station_coordinates(self, client_base_url='IRIS') Use an obspy FDSN client to retrieve station locations for all traces in the stream. The results are written into a sac header-like dictionary. Parameters ---------- self : stfinv.Stream() Stream with signals. client_base_url : str String with valid URL for FDSN client. """ client = Client(client_base_url) # bulk = [] network = ['II'] inv = client.get_stations(network='II') for tr in self: stats = tr.stats # Get all networks of which stations are contained in self. # This is more stable than requesting a bulk of the stations # in self. if stats.network not in network: network.append(stats.network) inv += client.get_stations(network=stats.network) # Correct Instaseis Streams if stats.location in ['', 'SE']: stats.location = u'' stats.channel = u'BH%s' % (stats.channel[2]) for tr in self: stats = tr.stats if not hasattr(stats, 'sac'): stat = inv.select(network=stats.network, station=stats.station, location=stats.location, channel=stats.channel) if (len(stat) > 0): stats.sac = dict(stla=stat[0][0].latitude, stlo=stat[0][0].longitude) else: print('Could not find station %s.%s.%s.%s' % (stats.network, stats.station, stats.location, stats.channel)) raise IndexError
def get_and_remove_response(station, channel, location, output, t1, duration): client = Client("http://service.geonet.org.nz") st = client.get_waveforms(network="NZ", station=station, location=location, channel=channel, starttime=t1, endtime=t1 + duration) tr = Stream() st.merge() print(st) for n in range(len(st)): inv = client.get_stations(network=st[n].stats.network, station=st[n].stats.station, location=st[n].stats.location, channel=st[n].stats.channel, level="response", startbefore=t1, endafter=t1 + duration) # st[n].detrend('linear') # st[n].taper(max_percentage=0.05, type='cosine') st[n].filter('bandpass', freqmin=0.1, freqmax=0.2, zerophase=True) st[n].remove_response(output=output, pre_filt=False, plot=False, water_level=60, inventory=inv) tr += st[n] return tr
def rm_response_(trace_path, comps, locs, outdir, client): tr = read(trace_path)[0] network = tr.stats.network station = tr.stats.station channel = tr.stats.channel location = tr.stats.location start = tr.stats.starttime end = tr.stats.endtime try: tr.remove_response() print 'response was attached' except Exception, message: print message inv = None fdsn_client = Client(client) for comp, loc in product(comps[channel], locs[location]): try: inv = fdsn_client.get_stations(network=network, station=station, location=loc, channel=comp, level='response', starttime=start, endtime=end) break except Exception, message: print message pass
def geonet_south_island(level="station"): """ Return geonet broadband stations in an obspy network :type level: str :param level: level to propogate network creation :rtype: obspy.core.inventory.network.Network """ c = Client("GEONET") # Extended North Island coverage, Kaikoura to East Cape lat_min = -48. lat_max = -40. lon_min = 165. lon_max = 175. starttime = UTCDateTime("2000-01-01") # GeoNet Broadband instruments with standard station code Z inv_geonet = c.get_stations(network="NZ", station="*Z", channel="HH?", minlatitude=lat_min, maxlatitude=lat_max, minlongitude=lon_min, maxlongitude=lon_max, level=level, starttime=starttime, endtime=UTCDateTime()) return inv_geonet[0]
def main(clientid: str, eventid: str, stationid: str, location_code: str, duration: float): client = Client(clientid) try: event = client.get_events(eventid=eventid)[0] except: raise FileNotFoundError(f"Event id not recognised {eventid}") origin = event.preferred_origin() or event.origins[0] station = client.get_stations(station=stationid, location=location_code, endafter=origin.time, startbefore=origin.time)[0][0] # Predict arrival times using TauP degrees_dist = locations2degrees(station.latitude, station.longitude, origin.latitude, origin.longitude) p_arrival = origin.time + MODEL.get_travel_times( source_depth_in_km=origin.depth / 1000.0, distance_in_degree=degrees_dist, phase_list=["P"])[0].time # Get waveforms around that time st = client.get_waveforms(station=stationid, location=location_code, starttime=p_arrival - 30, network="*", channel="BH?", endtime=p_arrival + duration) return define_plot(origin=origin, station=station, st=st)
def get_and_remove_response(station, channel, location, output, t1, duration=100): client = Client("http://service.iris.edu") st = client.get_waveforms(network="IU", station=station, location=location, channel=channel, starttime=t1, endtime=t1 + duration) tr = Stream() for n in range(len(st)): st.merge()[n] inv = client.get_stations(network=st[n].stats.network, station=st[n].stats.station, location=st[n].stats.location, channel=st[n].stats.channel, level="response", startbefore=t1, endafter=t1 + duration) # pre_filt = (0.005, 0.006, 30.0, 35.0) st[n].remove_response(output=output, pre_filt=False, plot=False, water_level=60, inventory=inv) tr += st[n] return tr
class Query(): def __init__(self): self.client = Client("IRIS") def get_events(self, starttime=UTCDateTime(2000, 1, 1), endtime=UTCDateTime.now(), **kwargs): chunk_length = 365 * 86400 # Query length in seconds events = Catalog() while starttime <= endtime: print(starttime) events += self.client.get_events(starttime=starttime, endtime=starttime + chunk_length, **kwargs) if starttime + chunk_length > endtime: chunk = endtime - starttime if chunk <= 1: break starttime += chunk_length self.events = _cat2df(events) def get_stations(self, includerestricted=False, **kwargs): self.stations = self.client.get_stations(includerestricted=includerestricted, **kwargs) def get_conti(self, starttime, endtime, hours=24): self.conti_time = [] nowtime = starttime while nowtime < endtime: nexttime = nowtime + timedelta(hours=hours) self.conti_time.append([nowtime, nexttime]) nowtime = nexttime
def sitemap(mseedid, data_provider='ETH', ax=None, self=None): if self is None: self = PSDs() if not hasattr(self, 'resps'): self.resps = {} c = Client(data_provider) if mseedid not in self.resps: msid = mseedid.split('.') self.resps[mseedid] = c.get_stations(network=msid[0], station=msid[1], location=msid[2], channel=msid[3], level="response") if ax is None: ax = plt.figure(figsize=(7, 9)).add_subplot(111) longitude = self.resps[mseedid][-1][-1][-1].longitude latitude = self.resps[mseedid][-1][-1][-1].latitude print(longitude, latitude) if False: map = Basemap(llcrnrlon=longitude - 0.001, llcrnrlat=latitude - 0.001, urcrnrlon=longitude + 0.001, urcrnrlat=latitude - 0.001, epsg=4326, projection='merc', ax=ax) map.arcgisimage(service='ESRI_Imagery_World_2D', xpixels=1500, verbose=True) return ax
def create_nodes_from_fdsn(self, base_url, network_code, station_codes, channel_codes, location_codes, country_code="", node_prefix=""): ''' Creates WebObs Nodes architecture and configuration files from FDSN Web Service (fdsnws) :type base_url: str :param base_url: A string representing the FDSN provider URL. :type network_code: str :param network_code: A string representing the FDSN network code. :type station_codes: str :param station_codes: A string representing the FDSN station(s) (wildcard accepted). :type channel_codes: str :param channel_codes: A string representing the FDSN channel(s) (wildcard accepted). :type location_codes: str :param location_codes: A string representing the FDSN location code(s) (wildcard accepted). :type country_code: str, optional :param country_code: A string representing the country code. :type node_prefix: str, optional :param node_prefix: A string representing the node prefix. ''' # Connect to FDSN web service and retrieve inventory fdsn_client = Client(base_url=base_url) inventory = fdsn_client.get_stations(network=network_code, station=station_codes, channel=channel_codes, location=location_codes, level="response") for network in inventory.networks: print("Processing %s network" % (network.code)) for station in network.stations: print("|--Processing %s station" % (station.code)) # Create node name and path node_name = "%s%s%s" % (country_code, node_prefix, station.code) node_path = "%s/%s" % (self.output_dir, node_name) # Create file tree and files if not os.path.exists(node_path): os.makedirs(node_path) os.makedirs("%s/DOCUMENTS/THUMBNAILS" % (node_path)) os.makedirs("%s/FEATURES" % (node_path)) os.makedirs("%s/INTERVENTIONS" % (node_path)) os.makedirs("%s/PHOTOS/THUMBNAILS" % (node_path)) os.makedirs("%s/SCHEMAS/THUMBNAILS" % (node_path)) open("%s/acces.txt" % (node_path), 'a').close() open("%s/info.txt" % (node_path), 'a').close() open("%s/installation.txt" % (node_path), 'a').close() open("%s/%s.kml" % (node_path, node_name), 'a').close() open("%s/FEATURES/sensor.txt" % (node_path), 'a').close() open("%s/INTERVENTIONS/%s_Projet.txt" % (node_path, node_name), 'a').close() self.create_clb_file(node_path=node_path, node_name=node_name, network_code=network.code, station=station)
def test_redirection(self): """ Tests the redirection of GET and POST requests. We redirect everything if not authentication is used. IRIS runs three services to test it: http://ds.iris.edu/files/redirect/307/station/1 http://ds.iris.edu/files/redirect/307/dataselect/1 http://ds.iris.edu/files/redirect/307/event/1 """ c = Client("IRIS", service_mappings={ "station": "http://ds.iris.edu/files/redirect/307/station/1", "dataselect": "http://ds.iris.edu/files/redirect/307/dataselect/1", "event": "http://ds.iris.edu/files/redirect/307/event/1"}, user_agent=USER_AGENT) st = c.get_waveforms( network="IU", station="ANMO", location="00", channel="BHZ", starttime=UTCDateTime("2010-02-27T06:30:00.000"), endtime=UTCDateTime("2010-02-27T06:30:01.000")) # Just make sure something is being downloaded. self.assertTrue(bool(len(st))) inv = c.get_stations( starttime=UTCDateTime("2000-01-01"), endtime=UTCDateTime("2001-01-01"), network="IU", station="ANMO", level="network") # Just make sure something is being downloaded. self.assertTrue(bool(len(inv.networks))) cat = c.get_events(starttime=UTCDateTime("2001-01-07T01:00:00"), endtime=UTCDateTime("2001-01-07T01:05:00"), catalog="ISC") # Just make sure something is being downloaded. self.assertTrue(bool(len(cat))) # Also test the bulk requests which are done using POST requests. bulk = (("TA", "A25A", "", "BHZ", UTCDateTime("2010-03-25T00:00:00"), UTCDateTime("2010-03-25T00:00:01")), ("TA", "A25A", "", "BHE", UTCDateTime("2010-03-25T00:00:00"), UTCDateTime("2010-03-25T00:00:01"))) st = c.get_waveforms_bulk(bulk, quality="B", longestonly=False) # Just make sure something is being downloaded. self.assertTrue(bool(len(st))) starttime = UTCDateTime(1990, 1, 1) endtime = UTCDateTime(1990, 1, 1) + 10 bulk = [ ["IU", "ANMO", "", "BHE", starttime, endtime], ["IU", "CCM", "", "BHZ", starttime, endtime], ] inv = c.get_stations_bulk(bulk, level="network") # Just make sure something is being downloaded. self.assertTrue(bool(len(inv.networks)))
def inv4stream(stream, network, client_name): start = stream[0].stats.starttime end = stream[0].stats.endtime client = Client(client_name) inv = client.get_stations(network=network, starttime=start, endtime=end) return inv
def plot_stations(network): """ Draws a map of stations in an IRIS network. """ client = Client('IRIS') network = network inventory = client.get_stations(network=network) net = inventory[0] lons = [] lats = [] names = [] # extract the values we want from the inventory for sta in net: lons.append(sta.longitude) lats.append(sta.latitude) names.append(sta.code) #pad out the region we're going to draw region = [np.min(lons), np.max(lons), np.min(lats), np.max(lats)] x_pad = (region[1] - region[0]) * 0.1 y_pad = (region[3] - region[2]) * 0.1 region = [ region[0] - x_pad, region[1] + x_pad, region[2] - y_pad, region[3] + y_pad ] # Set up the stereographic projection lon_0 = np.mean(region[:2]) lat_0 = np.mean(region[2:]) if lat_0 > 0: ref_lat = 90 else: ref_lat = -90 # GMT strings projection = f'S{lon_0}/{ref_lat}/6i' map_scale = f'JTL+c{lon_0}+w100k+f' rose = 'JML+w1i+f3+l' # Create figure fig = pygmt.Figure() fig.grdimage( grid='@earth_relief_15s', region=region, projection=projection, frame=['a', f'+t"{network} Seismograph Network"'], shading=True, ) fig.coast(shorelines=True) fig.basemap(map_scale=map_scale, rose=rose) fig.plot(lons, lats, style='i0.2i', color='red', pen=True) fig.text(x=lons, y=lats, text=names, justify='CT', offset='j0/0.5') return fig
def geonet_waveforms(station_code, start, end): """ Get waveforms from geonet for comparison against BEACON """ print(f"GeoNet waveform {station_code}", end="... ") net, sta, loc, cha = station_code.split('.') path_to = "./data" fid = os.path.join(path_to, f"{station_code}.D.{start.year}.{start.julday:0>3}") inv_fid = os.path.join(path_to, f"RESP.{net}.{sta}.{loc}.{cha}") # Get Data if os.path.exists(fid) and os.path.exists(inv_fid): print("internal") st = read(fid) inv = read_inventory(inv_fid) else: print("external", end="... ") c = Client("GEONET") try: st = c.get_waveforms(network=net, station=sta, location=loc, channel=cha, starttime=start, endtime=end, attach_response=False) except FDSNException: raise FileNotFoundError(f"GeoNet waveforms could not be fetched") try: inv = c.get_stations(network=net, station=sta, location=loc, channel=cha, starttime=start, endtime=end, level="response") except FDSNException: raise FileNotFoundError(f"GeoNet inventory could not be fetched") print("writing") st.write(fid, format="mseed") inv.write(inv_fid, format="stationxml") if not st: raise FileNotFoundError(f"GeoNet data not found for {station_code}") if len(st) > 1: raise Exception("Non continuous data") st.trim(start, end) return st, inv
def GeoNetFDSNrequest(date1, date2, net, sta, loc, cmp): """ Request waveform and meta data from GeoNet's FDSN webservices. """ #GeoNet's FDSN web servers arc_client = Client('http://service.geonet.org.nz') nrt_client = Client('http://beta-service-nrt.geonet.org.nz') time1 = UTCDateTime(date1) time2 = UTCDateTime(date2) try: st = nrt_client.get_waveforms(net, sta, loc, cmp, time1, time2, attach_response=True) inv = nrt_client.get_stations(network=net, station=sta, starttime=time1, endtime=time2) except FDSNNoDataException: st = arc_client.get_waveforms(net, sta, loc, cmp, time1, time2, attach_response=True) inv = arc_client.get_stations(network=net, station=sta, starttime=time1, endtime=time2) return (st, inv)
def get_channel_orientation(t0, net, st0, loc, duration, channel): """ Get the station channel orientation. Returns azimuth and dip angle. """ client = Client('IRIS') st0 = client.get_stations(starttime=t0, endtime=t0+duration*60, network=net, station=st0, channel=channel, level='channel') return st0[0][0].channels[0].azimuth, st0[0][0].channels[0].dip
def setUpClass(cls): from obspy.clients.fdsn import Client client = Client('IRIS') t1 = UTCDateTime('2012-03-26T00:00:00') t2 = t1 + (3 * 86400) cls.catalog = client.get_events( starttime=t1, endtime=t2, latitude=0, longitude=170, maxradius=40) cls.inventory = client.get_stations( starttime=t1, endtime=t2, latitude=0, longitude=170, maxradius=40)
def test_radial_queries(self): client = FDSNClient(self.live_server_url) lat = 48.995167 + 1.0 lon = 11.519922 self.assertEqual( len( client.get_stations(latitude=lat, longitude=lon, maxradius=2).get_contents()["stations"]), 1) self.assertEqual( len( client.get_stations(latitude=lat, longitude=lon, maxradius=1.1).get_contents()["stations"]), 1) with self.assertRaises(FDSNException): client.get_stations(latitude=lat, longitude=lon, minradius=1.1, maxradius=10) with self.assertRaises(FDSNException): client.get_stations(latitude=lat, longitude=lon, minradius=0.1, maxradius=0.5)
def get_inventory(): try: return read_inventory(invname) except Exception: pass client = Client('GFZ') net, sta, loc, cha = seedid.split('.') inv = client.get_stations(starttime=t1, endtime=t2, network=net, station=sta, location=loc, channel=cha, level='channel') # latitude=lat, longitude=lon, maxradius=10) inv.write(invname, 'STATIONXML') return inv
def test_sim_WA(self): """ Test simulating a Wood Anderson instrument. """ t1 = UTCDateTime("2010-09-3T16:30:00.000") t2 = UTCDateTime("2010-09-3T17:00:00.000") fdsn_client = Client('IRIS') st = fdsn_client.get_waveforms( network='NZ', station='BFZ', location='10', channel='HHZ', starttime=t1, endtime=t2, attach_response=True) inventory = fdsn_client.get_stations( network='NZ', station='BFZ', location='10', channel='HHZ', starttime=t1, endtime=t2, level="response") tr = st[0] # Test with inventory _sim_WA(trace=tr, inventory=inventory, water_level=10)
def redownload_statxml(st, network, station, statfile): """Errorhandler: Redownload station xml in case that it is not found.""" for c in tmp.re_client: try: client = Client(c) station_inv = client.get_stations(level="response", network=network, station=station) # write the new, working stationxml file station_inv.write(statfile, format="STATIONXML") break except (header.FDSNNoDataException, header.FDSNException): pass # wrong client return station_inv
def inv4stream(stream, client_name): stat = "" for i, trace in enumerate(stream): if i > 0: if trace.stats.station == stream[i - 1].stats.station: continue stat = stat + trace.stats.station + ',' stat = str(stat) client = Client(client_name) inv = client.get_stations(station=stat) return inv
def download_stationxml(stations, starttime, endtime, outputdir=None, client=None, level="response"): if client is None: client = Client("IRIS") if starttime > endtime: raise ValueError("Starttime(%s) is larger than endtime(%s)" % (starttime, endtime)) if not os.path.exists(outputdir): raise ValueError("Outputdir not exists: %s" % outputdir) _status = {} for station_id in stations: error_code = "None" network, station, location, channel = _parse_station_id(station_id) if outputdir is not None: filename = os.path.join(outputdir, "%s.xml" % station_id) if os.path.exists(filename): os.remove(filename) else: filename = None try: inv = client.get_stations(network=network, station=station, location=location, channel=channel, starttime=starttime, endtime=endtime, level=level) if len(inv) == 0: error_code = "Inventory Empty" if filename is not None and len(inv) > 0: inv.write(filename, format="STATIONXML") except Exception as e: error_code = "Failed to download StationXML '%s' due to: %s" \ % (station_id, str(e)) print(error_code) _status[station_id] = error_code return {"inventory": inv, "status": _status}
def get_inventory(): print('Read inventory file') try: return read_inventory(invname, 'STATIONXML') except: pass print('Create inventory file...') client = FSDNClient('ORFEUS') inv = client.get_stations(**inventory_kwargs) for net in inv: for sta in net[:]: if sta.code not in stations: net.stations.remove(sta) inv.write(invname, 'STATIONXML') return inv
def get_dataless(net, stime, etime, client): if os.path.exists(path + net + '_metadata.pickle'): with open(path + net + '_metadata.pickle', 'rb') as fhand: inv = pickle.load(fhand) else: client = Client() inv = client.get_stations(starttime=stime, endtime=etime, station="*", channel=chan1, network=net, level="response") with open(path + net + '_metadata.pickle', 'wb') as fhand: pickle.dump(inv, fhand) return inv
def hobitss(level="station"): """ Return hobitss broadband OBS sensors (trillium compacts) :type level: str :param level: level to propogate network creation :rtype: obspy.core.inventory.network.Network """ c = Client("IRIS") inv_hobitss = c.get_stations(network='YH', station="LOBS*", location='', channel="HH?", level=level) return inv_hobitss[0]
def test_total_and_selected_number_of_sta_and_cha(self): client = FDSNClient(self.live_server_url) inv = client.get_stations(level="network") self.assertEqual(inv[0].total_number_of_stations, 1) self.assertEqual(inv[0].selected_number_of_stations, 0) inv = client.get_stations(level="station") self.assertEqual(inv[0].total_number_of_stations, 1) self.assertEqual(inv[0].selected_number_of_stations, 1) self.assertEqual(inv[0][0].total_number_of_channels, 3) self.assertEqual(inv[0][0].selected_number_of_channels, 0) inv = client.get_stations(level="channel") self.assertEqual(inv[0].total_number_of_stations, 1) self.assertEqual(inv[0].selected_number_of_stations, 1) self.assertEqual(inv[0][0].total_number_of_channels, 3) self.assertEqual(inv[0][0].selected_number_of_channels, 3) inv = client.get_stations(level="response") self.assertEqual(inv[0].total_number_of_stations, 1) self.assertEqual(inv[0].selected_number_of_stations, 1) self.assertEqual(inv[0][0].total_number_of_channels, 3) self.assertEqual(inv[0][0].selected_number_of_channels, 3)
def get_station_location(t0, net, st0, loc): """ Get the station latitude, longitude, and elevation. Given a time, duration, loc code, and station network/name, get station information from IRIS. Return a list containing the lat, lon, and elevation. """ client = Client('IRIS') st0 = client.get_stations(starttime=t0, endtime=t0+timedelta(seconds=60), network=net, station=st0, level='station') slat = st0[0][0].latitude slon = st0[0][0].longitude selev = st0[0][0].elevation return [slat, slon, selev]
def get_from_iris(level="station"): """ Return available broadband stations from IRIS :type level: str :param level: level to propogate network creation :rtype: obspy.core.inventory.network.Network """ c = Client("IRIS") # A whole-Alaska bounding box including western Canada and Aleutians lat_min = 52.17 # South lat_max = 72.23 # North lon_min = -178.04 # West lon_max = -121.04 # East starttime = UTCDateTime("2000-01-01") networks = [ "AK", # Alaska Regional Network "AT", # National Tsunami Warning Center (Alaska Seismic Network) "AV", # Alaska Volcano Observatory "CN", # Canadian National Seismograph Network "II", # Global Seismograph Network (GSN) "IU", # Global Seismograph Network (GSN) "NY", # Yukon-Northwest Seismic Network "TA", # USArray Transportable Array "US", # United States National Seismic Network "YO", # Yukon Observatory ] channels = ["BH?", "BL?", "HH?", "HL?"] # ObsPy doesnt accept lists or bracketed wildcards, must be comma separated networks = ",".join(networks) channels = ",".join(channels) inv_alaska = c.get_stations(network=networks, station="*", channel=channels, minlatitude=lat_min, maxlatitude=lat_max, minlongitude=lon_min, maxlongitude=lon_max, level=level, starttime=starttime, endtime=UTCDateTime()) return inv_alaska
def Doit(): from sys import argv nstas = [argv[1]] # nstas=['FS05B'] print("doing nstas", nstas) client = Client("IRIS") t1 = UTCDateTime(year=2012, julday=1) t2 = UTCDateTime(year=2012, julday=365) inventory = client.get_stations(network='7D', starttime=t1, endtime=t2) allstas = {} for sta in inventory[0].stations: nsta = sta.code xlat = sta.latitude xlon = sta.longitude xdep = sta.elevation allstas[nsta] = (xlat, xlon, np.abs(xdep)) cat = read_events("cmt2012.ndk") cat = cat.filter("magnitude >= 5.0") cat_large = cat.filter("magnitude >= 5.5") t1_all = [] for item in cat_large: t1_all.append(item.origins[0].time) print("number of evenst:", len(t1_all)) # t1_all.append(cat_large[100].origins[0].time) # print(t1_all) for nsta in nstas: outfile = './' + nsta + '_result_new.txt' # for t1 in t1_all[100:101]: for t1 in t1_all: fobj = open(outfile, 'a') t2 = t1 + 86400 print("doing", nsta, t1) ierr, angle, coh, adm, phs, coh2, adm2, phs2 = DoDay(nsta, t1, t2, cat, allstas, iopt=2) fobj.write("%3d %3d %10.3f %10.3f %12.5g %12.5g %10.3f %12.5g %12.5g\n" \ % (ierr,t1.julday,np.rad2deg(angle),coh,adm,phs,coh2,adm2,phs2)) fobj.close()
def download_stationxml(stations, starttime, endtime, outputdir=None, client=None, level="response"): if client is None: client = Client("IRIS") if starttime > endtime: raise ValueError("Starttime(%s) is larger than endtime(%s)" % (starttime, endtime)) if not os.path.exists(outputdir): raise ValueError("Outputdir not exists: %s" % outputdir) _status = {} for station_id in stations: error_code = "None" network, station, location, channel = _parse_station_id(station_id) if outputdir is not None: filename = os.path.join(outputdir, "%s.xml" % station_id) if os.path.exists(filename): os.remove(filename) else: filename = None try: inv = client.get_stations( network=network, station=station, location=location, channel=channel, starttime=starttime, endtime=endtime, level=level) if len(inv) == 0: error_code = "Inventory Empty" if filename is not None and len(inv) > 0: inv.write(filename, format="STATIONXML") except Exception as e: error_code = "Failed to download StationXML '%s' due to: %s" \ % (station_id, str(e)) print(error_code) _status[station_id] = error_code return {"inventory": inv, "status": _status}
def download_stationxml(stations, starttime, endtime, outputdir=".", client=None, level="response"): if client is None: client = Client("IRIS") if starttime > endtime: raise ValueError("Starttime(%s) is larger than endtime(%s)" % (starttime, endtime)) if not os.path.exists(outputdir): raise ValueError("Outputdir not exists: %s" % outputdir) _status = {} for station_id in stations: network, station, location, channel = _parse_station_id(station_id) filename = os.path.join(outputdir, "%s.xml" % station_id) if os.path.exists(filename): os.remove(filename) try: inv = client.get_stations( network=network, station=station, location=location, channel=channel, starttime=starttime, endtime=endtime, level=level) if len(inv) > 0: inv.write(filename, format="STATIONXML") error_code = 0 else: error_code = 1 except Exception as e: print("Failed to download StationXML '%s' due to: %s" % (station_id, str(e))) error_code = 2 _status[station_id] = error_code return _status
def get_inventory(self): starttime = UTCDateTime() endtime = UTCDateTime() client = Client(self.fdsn_server) for s in self.streams: net, sta, chan, loc = s inv = client.get_stations(starttime=starttime, endtime=endtime, network=net, station=sta, location=loc, channel=chan, level="response") channels = set(inv.get_contents()['channels']) for c in channels: try: coords = inv.get_coordinates(c, datetime=starttime) except: try: coords = inv.get_coordinates(c) except: print c, "No matching coordinates found" continue latitude = coords['latitude'] longitude = coords['longitude'] elevation = coords['elevation'] self.station_coordinfo[c] = \ {"latitude": latitude, "longitude": longitude, "elevation": elevation, "geohash": Geohash.encode(latitude, longitude, precision=7) }
def test_radial_queries(self): client = FDSNClient(self.live_server_url) lat = 48.995167 + 1.0 lon = 11.519922 self.assertEqual( len(client.get_stations( latitude=lat, longitude=lon, maxradius=2).get_contents()["stations"]), 1) self.assertEqual( len(client.get_stations( latitude=lat, longitude=lon, maxradius=1.1).get_contents()["stations"]), 1) with self.assertRaises(FDSNException): client.get_stations(latitude=lat, longitude=lon, minradius=1.1, maxradius=10) with self.assertRaises(FDSNException): client.get_stations(latitude=lat, longitude=lon, minradius=0.1, maxradius=0.5)
def data_request(client_name, cat_client_name, start, end, minmag, net=None, scode="*", channels="*", minlat=None, maxlat=None,minlon=None,maxlon=None, station_minlat=None, station_maxlat=None, station_minlon=None, station_maxlon=None, mindepth=None, maxdepth=None, radialcenterlat=None, radialcenterlon=None, minrad=None, maxrad=None, station_radialcenterlat=None, station_radialcenterlon=None, station_minrad=None, station_maxrad=None, azimuth=None, baz=False, t_before_first_arrival=1, t_after_first_arrival=9, savefile=False, file_format='SAC'): """ Searches in a given Database for seismic data. Restrictions in terms of starttime, endtime, network etc can be made. If data is found it returns a stream variable, with the waveforms, an inventory with all station and network information and a catalog with the event information. :param client_name: Name of desired fdsn client, for a list of all clients see: https://docs.obspy.org/tutorial/code_snippets/retrieving_data_from_datacenters.html :type client_name: string :param cat_client_name: Name of Event catalog :type cat_client_name: string :param start, end: starttime, endtime :type : UTCDateTime :param minmag: Minimum magnitude of event :type minmag: float :param net: Network code for which to search data for :type net: string :param scode: Station code for which to search data for :type scode: string :param channels: Used channels of stations :type channels: string :param minlat, maxlat, minlon, maxlon: Coordinate-window of interest :type : float :param mindepth, maxdepth: depth information of event in km :type : float :param radialcenterlat, radialcenterlon: Centercoordinates of a radialsearch, if radialsearch=True :type : float :param minrad, maxrad: Minimum and maximum radii for radialsearch :type : float :param azimuth: Desired range of azimuths of event, station couples in deg as a list [minimum azimuth, maximum azimuth] :type azimuth: list :param baz: Desired range of back-azimuths of event, station couples in deg as a list [minimum back azimuth, maximum back azimuth] :type baz: list :param t_before_first_arrival, t_before_after_arrival: Length of the seismograms, startingpoint, minutes before 1st arrival and minutes after 1st arrival. :type t_before_first_arrival, t_before_after_arrival: float, int :param savefile: if True, Stream, Inventory and Catalog will be saved local, in the current directory. :type savefile: bool :param format: File-format of the data, for supported formats see: https://docs.obspy.org/packages/autogen/obspy.core.stream.Stream.write.html#obspy.core.stream.Stream.write :type format: string returns :param: list_of_stream, Inventory, Catalog :type: list, obspy, obspy ### Example 1 ### from obspy import UTCDateTime from sipy.util.data_request import data_request start = UTCDateTime(2010,1,1,0,0) end = UTCDateTime(2010,12,31,0,0) minmag = 8 station = '034A' list_of_stream, inventory, cat = data_request('IRIS', start, end, minmag, net='TA', scode=station) st = list_of_stream[0] st = st.select(channel='BHZ') st.normalize() inv = inventory[0] st.plot() inv.plot() cat.plot() ### Example 2 ### from obspy import UTCDateTime from sipy.util.data_request import data_request start = UTCDateTime(2010,1,1,0,0) end = UTCDateTime(2010,12,31,0,0) minmag = 8 station = '034A' client = 'IRIS' cat_client = 'globalcmt' list_of_stream, inventory, cat = data_request(client, cat_client, start, end, minmag, net='TA', scode=station) st = list_of_stream[0] st = st.select(channel='BHZ') st.normalize() inv = inventory[0] st.plot() inv.plot() cat.plot() """ data =[] stream = Stream() streamall = [] #build in different approach for catalog search, using urllib if cat_client_name == 'globalcmt': catalog = request_gcmt(starttime=start, endtime=end, minmagnitude=minmag, mindepth=mindepth, maxdepth=maxdepth, minlatitude=minlat, maxlatitude=maxlat, minlongitude=minlon, maxlongitude=maxlon) client = Client(client_name) else: client = Client(client_name) try: catalog = client.get_events(starttime=start, endtime=end, minmagnitude=minmag, mindepth=mindepth, maxdepth=maxdepth, latitude=radialcenterlat, longitude=radialcenterlon, minradius=minrad, maxradius=maxrad,minlatitude=minlat, maxlatitude=maxlat, minlongitude=minlon, maxlongitude=maxlon) except: print("No events found for given parameters.") return print("Following events found: \n") print(catalog) m = TauPyModel(model="ak135") Plist = ["P", "Pdiff", "p"] for event in catalog: print("\n") print("########################################") print("Looking for available data for event: \n") print(event.short_str()) print("\n") origin_t = event.origins[0].time station_stime = UTCDateTime(origin_t - 3600*24) station_etime = UTCDateTime(origin_t + 3600*24) try: inventory = client.get_stations(network=net, station=scode, level="station", starttime=station_stime, endtime=station_etime, minlatitude=station_minlat, maxlatitude=station_maxlat, minlongitude=station_minlon, maxlongitude=station_maxlon, latitude=station_radialcenterlat, longitude=station_radialcenterlon, minradius=station_minrad, maxradius=station_maxrad) print("Inventory found.") except: print("No Inventory found for given parameters") return for network in inventory: elat = event.origins[0].latitude elon = event.origins[0].longitude depth = event.origins[0].depth/1000. array_fits = True if azimuth or baz: cog=center_of_gravity(network) slat = cog['latitude'] slon = cog['longitude'] epidist = locations2degrees(slat,slon,elat,elon) arrivaltime = m.get_travel_times(source_depth_in_km=depth, distance_in_degree=epidist, phase_list=Plist) P_arrival_time = arrivaltime[0] Ptime = P_arrival_time.time tstart = UTCDateTime(event.origins[0].time + Ptime - t_before_first_arrival * 60) tend = UTCDateTime(event.origins[0].time + Ptime + t_after_first_arrival * 60) center = geometrical_center(inv) clat = center['latitude'] clon = center['longitude'] if azimuth: print("Looking for events in the azimuth range of %f to %f" % (azimuth[0], azimuth[1]) ) center_az = gps2dist_azimuth(clat, clon, elat, elon)[1] if center_az > azimuth[1] and center_az < azimuth[0]: print("Geometrical center of Array out of azimuth bounds, \ncheking if single stations fit") array_fits = False elif baz: print("Looking for events in the back azimuth range of %f to %f" %(baz[0], baz[1])) center_baz = gps2dist_azimuth(clat, clon, elat, elon)[2] if center_baz > baz[1] and center_baz < baz[0]: print("Geometrical center of Array out of back azimuth bounds, \ncheking if single stations fit") array_fits = False # If array fits to azimuth/back azimuth or no azimuth/back azimuth is given no_of_stations = 0 if array_fits: for station in network: epidist = locations2degrees(station.latitude,station.longitude,elat,elon) arrivaltime = m.get_travel_times(source_depth_in_km=depth, distance_in_degree=epidist, phase_list=Plist) P_arrival_time = arrivaltime[0] Ptime = P_arrival_time.time tstart = UTCDateTime(event.origins[0].time + Ptime - t_before_first_arrival * 60) tend = UTCDateTime(event.origins[0].time + Ptime + t_after_first_arrival * 60) try: streamreq = client.get_waveforms(network=network.code, station=station.code, location='*', channel=channels, starttime=tstart, endtime=tend, attach_response=True) no_of_stations += 1 print("Downloaded data for %i of %i available stations!" % (no_of_stations, network.selected_number_of_stations), end='\r' ) sys.stdout.flush() stream += streamreq try: if inventory_used: inventory_used += client.get_stations(network=net, station=scode, level="station", starttime=station_stime, endtime=station_etime, minlatitude=station_minlat, maxlatitude=station_maxlat, minlongitude=station_minlon, maxlongitude=station_maxlon, latitude=station_radialcenterlat, longitude=station_radialcenterlon, minradius=station_minrad, maxradius=station_maxrad) except: inventory_used = client.get_stations(network=net, station=scode, level="station", starttime=station_stime, endtime=station_etime, minlatitude=station_minlat, maxlatitude=station_maxlat, minlongitude=station_minlon, maxlongitude=station_maxlon, latitude=station_radialcenterlat, longitude=station_radialcenterlon, minradius=station_minrad, maxradius=station_maxrad) except: continue # If not checking each station individually. else: for station in network: epidist = locations2degrees(station.latitude,station.longitude,elat,elon) arrivaltime = m.get_travel_times(source_depth_in_km=depth, distance_in_degree=epidist, phase_list=Plist) P_arrival_time = arrivaltime[0] Ptime = P_arrival_time.time tstart = UTCDateTime(event.origins[0].time + Ptime - t_before_first_arrival * 60) tend = UTCDateTime(event.origins[0].time + Ptime + t_after_first_arrival * 60) fit = False if azimuth: stat_az = gps2dist_azimuth(station.latitude, station.longitude, elat, elon)[1] if stat_az > azimuth[1] and stat_az < azimuth[0]: fit = True elif baz: stat_baz = gps2dist_azimuth(station.latitude, station.longitude, elat, elon)[2] if stat_baz > baz[1] and stat_baz < baz[0]: fit = True if fit: try: streamreq = client.get_waveforms(network = network.code, station = station.code, location='*', channel = channels, startime = tstart, endtime = tend, attach_response = True) no_of_stations += 1 print("Downloaded data for %i of %i available stations!" % (no_of_stations, network.selected_number_of_stations), end='\r' ) sys.stdout.flush() stream += streamreq try: if inventory_used: inventory_used += client.get_stations(network=net, station=scode, level="station", starttime=station_stime, endtime=station_etime, minlatitude=station_minlat, maxlatitude=station_maxlat, minlongitude=station_minlon, maxlongitude=station_maxlon, latitude=station_radialcenterlat, longitude=station_radialcenterlon, minradius=station_minrad, maxradius=station_maxrad) except: inventory_used = client.get_stations(network=net, station=scode, level="station", starttime=station_stime, endtime=station_etime, minlatitude=station_minlat, maxlatitude=station_maxlat, minlongitude=station_minlon, maxlongitude=station_maxlon, latitude=station_radialcenterlat, longitude=station_radialcenterlon, minradius=station_minrad, maxradius=station_maxrad) except: continue try: if invall: invall += inventory except: invall = inventory attach_network_to_traces(stream, inventory) attach_coordinates_to_traces(stream, inventory, event) streamall.append(stream) stream = Stream() if savefile: stname = str(origin_t).split('.')[0] + ".MSEED" invname = stname + "_inv.xml" catname = stname + "_cat.xml" stream.write(stname, format=file_format) inventory.write(invname, format="STATIONXML") catalog.write(catname, format="QUAKEML") plt.ion() #invall.plot() #catalog.plot() plt.ioff() inventory = invall list_of_stream = streamall return(list_of_stream, inventory, catalog)
#If we arent doing manual station lists we need to get one for the network if parserval.sta: manstalist = True if debug: print("We are using a manual station list") stalist = parserval.sta.split(",") stations = [] for sta in stalist: stations.append(parserval.network + " " + sta) if debug: print(stations) else: manstalist = False stations = client.get_stations(network=parserval.network, starttime=eventtime, endtime=eventtime) stations = [ sta.code for sta in stations[0]] if debug: print("Here are the stations we found") for sta in stations: print("Here is a station:" + sta) #Lets start by using a station list and then move to a different approach for sta in stations: net = parserval.network cursta = sta #Now we get the data for the event
def fdsnws(base_url="http://arclink.ethz.ch:8080", endafter=40., maxradius=.6, location='*', channel='HNZ,HNE,HNN,HGZ,HGE,HGN,HHZ,HHE,HHN,EHZ,EHE,EHN,SHZ,SHE,SHN', stations_base_url=None, waveforms_base_url=None, quality=None, minimumlength=None, longestonly=None, correction_method = remove_sensitivity, eventid=None, **get_events_options): # First import : from obspy.clients.fdsn import Client fdsnclient = Client(base_url) # eventid in URL case if eventid is None: eventid = 'smi:ch.ethz.sed/sc3a/2017epaqsp' print('Picks default eventid:',eventid) elif '#' in eventid : eventid = eventid.split('#')[-1] print('Picks eventid in URL format:',eventid) # Special clients systems stationsclient = fdsnclient waveformsclient = fdsnclient if stations_base_url: stationsclient = Client(stations_base_url) if not waveforms_base_url: waveformsclient = Client(stations_base_url) if waveforms_base_url: waveformsclient = Client(waveforms_base_url) if not stations_base_url: stationsclient = Client(waveforms_base_url) # Load event fdsnclient.get_events(eventid=eventid,format='sc3ml',filename='events.xml', **get_events_options) eventstreams = {'catalog': obspy.read_events('events.xml',format='sc3ml'), 'inventory': obspy.core.inventory.Inventory([],None), 'raw' : obspy.core.Stream()} if eventstreams['catalog'] is None: print('catalog is',eventstreams['catalog']) for output in ['catalog','inventory','raw']: eventstreams[output].output=output for event in eventstreams['catalog'].events : # Load stations t=event.preferred_origin().time try: inventory = stationsclient.get_stations(level='station', startbefore=t, endafter=t+endafter, latitude=event.preferred_origin().latitude, longitude=event.preferred_origin().longitude, maxradius=maxradius, location=location, channel=channel) except: print('No station found for event:') print(event) print('Using client:') print(stationsclient) continue # Load waveforms addons = [location, channel] + [t,t+endafter] bulk = [tuple(station.split()[0].split('.')[:2]+addons) for station in inventory.get_contents()['stations']] try: waveforms = waveformsclient.get_waveforms_bulk(bulk, attach_response=True, quality=quality, minimumlength=minimumlength, longestonly=longestonly) except: print('No waveform found for request:') print(bulk) print('Using client:') print(waveformsclient) continue # Improve waveforms attributes for trace in waveforms: station = inventory.select(network=trace.stats.network, station=trace.stats.station).networks[0].stations[0] trace.stats.coordinates = {'latitude':station.latitude, 'longitude':station.longitude, 'elevation':station.elevation} distance = obspy.geodetics.base.gps2dist_azimuth(station.latitude, station.longitude, event.preferred_origin().latitude, event.preferred_origin().longitude)[0] distance = ((distance**2+(trace.stats.coordinates['elevation']*-1)**2.)**.5) distance = distance/len(eventstreams['catalog'].events) if not hasattr(trace.stats, 'distance'): trace.stats.distance = 0. trace.stats.distance += distance eventstreams['inventory'] += inventory eventstreams['raw'] += waveforms eventstreams['raw'].sort(keys=['distance']) if correction_method: eventstreams = correction_method(eventstreams) return eventstreams
def test_download_urls_for_custom_mapping(self, download_url_mock): """ Tests the downloading of data with custom mappings. """ base_url = "http://example.com" # More extensive mock setup simulation service discovery. def custom_side_effects(*args, **kwargs): if "version" in args[0]: return 200, "1.0.200" elif "event" in args[0]: with open(os.path.join( self.datapath, "2014-01-07_iris_event.wadl"), "rb") as fh: return 200, fh.read() elif "station" in args[0]: with open(os.path.join( self.datapath, "2014-01-07_iris_station.wadl"), "rb") as fh: return 200, fh.read() elif "dataselect" in args[0]: with open(os.path.join( self.datapath, "2014-01-07_iris_dataselect.wadl"), "rb") as fh: return 200, fh.read() return 404, None download_url_mock.side_effect = custom_side_effects # Some custom urls base_url_event = "http://example.com/beta/event_service/11" base_url_station = "http://example.org/beta2/station/7" base_url_ds = "http://example.edu/beta3/dataselect/8" # An exception will be raised if not actual WADLs are returned. # Catch warnings to avoid them being raised for the tests. with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") c = Client(base_url=base_url, service_mappings={ "event": base_url_event, "station": base_url_station, "dataselect": base_url_ds, }) for warning in w: self.assertTrue("Could not parse" in str(warning) or "cannot deal with" in str(warning)) # Test the dataselect downloading. download_url_mock.reset_mock() download_url_mock.side_effect = None download_url_mock.return_value = 404, None try: c.get_waveforms("A", "B", "C", "D", UTCDateTime() - 100, UTCDateTime()) except: pass self.assertTrue( base_url_ds in download_url_mock.call_args_list[0][0][0]) # Test the station downloading. download_url_mock.reset_mock() download_url_mock.side_effect = None download_url_mock.return_value = 404, None try: c.get_stations() except: pass self.assertTrue( base_url_station in download_url_mock.call_args_list[0][0][0]) # Test the event downloading. download_url_mock.reset_mock() download_url_mock.side_effect = None download_url_mock.return_value = 404, None try: c.get_events() except: pass self.assertTrue( base_url_event in download_url_mock.call_args_list[0][0][0])
def test_redirection_auth(self): """ Tests the redirection of GET and POST requests using authentication. By default these should not redirect and an exception is raised. """ # Clear the cache. Client._Client__service_discovery_cache.clear() # The error will already be raised during the initialization in most # cases. self.assertRaises( FDSNRedirectException, Client, "IRIS", service_mappings={ "station": "http://ds.iris.edu/files/redirect/307/station/1", "dataselect": "http://ds.iris.edu/files/redirect/307/dataselect/1", "event": "http://ds.iris.edu/files/redirect/307/event/1"}, user="******", password="******", user_agent=USER_AGENT) # The force_redirect flag overwrites that behaviour. c_auth = Client("IRIS", service_mappings={ "station": "http://ds.iris.edu/files/redirect/307/station/1", "dataselect": "http://ds.iris.edu/files/redirect/307/dataselect/1", "event": "http://ds.iris.edu/files/redirect/307/event/1"}, user="******", password="******", user_agent=USER_AGENT, force_redirect=True) st = c_auth.get_waveforms( network="IU", station="ANMO", location="00", channel="BHZ", starttime=UTCDateTime("2010-02-27T06:30:00.000"), endtime=UTCDateTime("2010-02-27T06:30:01.000")) # Just make sure something is being downloaded. self.assertTrue(bool(len(st))) inv = c_auth.get_stations( starttime=UTCDateTime("2000-01-01"), endtime=UTCDateTime("2001-01-01"), network="IU", station="ANMO", level="network") # Just make sure something is being downloaded. self.assertTrue(bool(len(inv.networks))) cat = c_auth.get_events(starttime=UTCDateTime("2001-01-07T01:00:00"), endtime=UTCDateTime("2001-01-07T01:05:00"), catalog="ISC") # Just make sure something is being downloaded. self.assertTrue(bool(len(cat))) # Also test the bulk requests which are done using POST requests. bulk = (("TA", "A25A", "", "BHZ", UTCDateTime("2010-03-25T00:00:00"), UTCDateTime("2010-03-25T00:00:01")), ("TA", "A25A", "", "BHE", UTCDateTime("2010-03-25T00:00:00"), UTCDateTime("2010-03-25T00:00:01"))) st = c_auth.get_waveforms_bulk(bulk, quality="B", longestonly=False) # Just make sure something is being downloaded. self.assertTrue(bool(len(st))) starttime = UTCDateTime(1990, 1, 1) endtime = UTCDateTime(1990, 1, 1) + 10 bulk = [ ["IU", "ANMO", "", "BHE", starttime, endtime], ["IU", "CCM", "", "BHZ", starttime, endtime], ] inv = c_auth.get_stations_bulk(bulk, level="network") # Just make sure something is being downloaded. self.assertTrue(bool(len(inv.networks)))
def FDSN_available(input_dics, event, target_path, event_number): """ Check the availablity of FDSN stations :param input_dics: :param event: :param target_path: :param event_number: :return: """ print "Check the availablity of FDSN stations: %s" % input_dics["fdsn_base_url"] client_fdsn = Client_fdsn( base_url=input_dics["fdsn_base_url"], user=input_dics["fdsn_user"], password=input_dics["fdsn_pass"] ) Sta_fdsn = [] try: if input_dics["fdsn_base_url"].lower() in ["resif"]: # start_time = None # end_time = None start_time = event["t1"] end_time = event["t2"] else: start_time = event["t1"] end_time = event["t2"] available = client_fdsn.get_stations( network=input_dics["net"], station=input_dics["sta"], location=input_dics["loc"], channel=input_dics["cha"], starttime=start_time, endtime=end_time, latitude=input_dics["lat_cba"], longitude=input_dics["lon_cba"], minradius=input_dics["mr_cba"], maxradius=input_dics["Mr_cba"], minlatitude=input_dics["mlat_rbb"], maxlatitude=input_dics["Mlat_rbb"], minlongitude=input_dics["mlon_rbb"], maxlongitude=input_dics["Mlon_rbb"], level="channel", ) for network in available.networks: for station in network: for channel in station: Sta_fdsn.append( [ network.code, station.code, channel.location_code, channel.code, channel.latitude, channel.longitude, channel.elevation, channel.depth, ] ) if input_dics["fdsn_bulk"] == "Y": if input_dics["fdsn_update"] != "N": if os.path.exists(os.path.join(target_path, "info", "bulkdata.txt")): os.remove(os.path.join(target_path, "info", "bulkdata.txt")) if os.path.exists(os.path.join(target_path, "info", "bulkdata.txt")): print "bulkdata.txt exists in the directory!" else: print "Start creating a list for bulk request" bulk_list = [] for bulk_sta in Sta_fdsn: if input_dics["cut_time_phase"]: t_start, t_end = calculate_time_phase(event, bulk_sta) else: t_start = event["t1"] t_end = event["t2"] bulk_list.append((bulk_sta[0], bulk_sta[1], bulk_sta[2], bulk_sta[3], t_start, t_end)) bulk_list_fio = open(os.path.join(target_path, "info", "bulkdata_list"), "a+") pickle.dump(bulk_list, bulk_list_fio) bulk_list_fio.close() except Exception as e: exc_file = open(os.path.join(target_path, "info", "exception"), "a+") ee = "fdsn -- Event: %s --- %s\n" % (str(event_number + 1), e) exc_file.writelines(ee) exc_file.close() print "ERROR: %s" % ee if len(Sta_fdsn) == 0: Sta_fdsn.append([]) Sta_fdsn.sort() return Sta_fdsn
def test_temporal_queries(self): """ Test the various temporal parameters. """ # All 3 channels start at the same time, two are open ended, # one ends a bit earlier. client = FDSNClient(self.live_server_url) start = obspy.UTCDateTime("2010-04-29T00:00:00.000000Z") end = obspy.UTCDateTime("2011-01-01T00:00:00.000000Z") inv = client.get_stations(starttime=obspy.UTCDateTime(2000, 1, 1), level="channel") c = inv.get_contents() self.assertEqual(c["channels"], ['BW.ALTM..EHE', 'BW.ALTM..EHN', 'BW.ALTM..EHZ']) self.assertEqual(len(c["networks"]), 1) self.assertEqual(len(c["stations"]), 1) self.assertEqual(len(c["channels"]), 3) # Same thing. c = client.get_stations(starttime=start - 10, level="channel").get_contents() self.assertEqual(len(c["networks"]), 1) self.assertEqual(len(c["stations"]), 1) self.assertEqual(len(c["channels"]), 3) # Go before and after the endtime of the one channel. c = client.get_stations(starttime=end - 10, level="channel").get_contents() self.assertEqual(len(c["networks"]), 1) self.assertEqual(len(c["stations"]), 1) self.assertEqual(len(c["channels"]), 3) c = client.get_stations(starttime=end + 10, level="channel").get_contents() self.assertEqual(len(c["networks"]), 1) self.assertEqual(len(c["stations"]), 1) self.assertEqual(len(c["channels"]), 2) # Test the endtime parameter. inv = client.get_stations(endtime=obspy.UTCDateTime(2016, 1, 1), level="channel") c = inv.get_contents() self.assertEqual(c["channels"], ['BW.ALTM..EHE', 'BW.ALTM..EHN', 'BW.ALTM..EHZ']) self.assertEqual(len(c["networks"]), 1) self.assertEqual(len(c["stations"]), 1) self.assertEqual(len(c["channels"]), 3) c = client.get_stations(endtime=start + 10, level="channel").get_contents() self.assertEqual(len(c["networks"]), 1) self.assertEqual(len(c["stations"]), 1) self.assertEqual(len(c["channels"]), 3) with self.assertRaises(FDSNException): client.get_stations(endtime=start - 10, level="channel") # startbefore c = client.get_stations(startbefore=start + 10, level="channel").get_contents() self.assertEqual(len(c["networks"]), 1) self.assertEqual(len(c["stations"]), 1) self.assertEqual(len(c["channels"]), 3) with self.assertRaises(FDSNException): client.get_stations(startbefore=start - 10, level="channel") # startafter c = client.get_stations(startafter=start - 10, level="channel").get_contents() self.assertEqual(len(c["networks"]), 1) self.assertEqual(len(c["stations"]), 1) self.assertEqual(len(c["channels"]), 3) with self.assertRaises(FDSNException): client.get_stations(startafter=start + 10, level="channel") # endbefore c = client.get_stations(endbefore=end + 10, level="channel").get_contents() self.assertEqual(len(c["networks"]), 1) self.assertEqual(len(c["stations"]), 1) self.assertEqual(len(c["channels"]), 1) with self.assertRaises(FDSNException): client.get_stations(endbefore=end - 10, level="channel") # endafter c = client.get_stations(endafter=end - 10, level="channel").get_contents() self.assertEqual(len(c["networks"]), 1) self.assertEqual(len(c["stations"]), 1) self.assertEqual(len(c["channels"]), 3) c = client.get_stations(endafter=end + 10, level="channel").get_contents() self.assertEqual(len(c["networks"]), 1) self.assertEqual(len(c["stations"]), 1) self.assertEqual(len(c["channels"]), 2)
def fdsn_available(input_dics, cl, event, target_path): """ check the availablity of FDSN stations :param input_dics: :param cl: :param event: :param target_path: :return: """ print("check the availability: %s" % input_dics['data_source'][cl]) if input_dics['username_fdsn']: include_restricted = True else: include_restricted = None sta_fdsn = [] try: client_fdsn = Client_fdsn( base_url=input_dics['data_source'][cl].upper(), user=input_dics['username_fdsn'], password=input_dics['password_fdsn']) available = client_fdsn.get_stations( network=input_dics['net'], station=input_dics['sta'], location=input_dics['loc'], channel=input_dics['cha'], starttime=event['t1'], endtime=event['t2'], latitude=input_dics['lat_cba'], longitude=input_dics['lon_cba'], minradius=input_dics['mr_cba'], maxradius=input_dics['Mr_cba'], minlatitude=input_dics['mlat_rbb'], maxlatitude=input_dics['Mlat_rbb'], minlongitude=input_dics['mlon_rbb'], maxlongitude=input_dics['Mlon_rbb'], includerestricted=include_restricted, level='channel') for network in available.networks: for station in network: for channel in station: st_id = '%s_%s_%s_%s' % (network.code, station.code, channel.location_code, channel.code) sta_fdsn.append([network.code, station.code, channel.location_code, channel.code, channel.latitude, channel.longitude, channel.elevation, channel.depth, input_dics['data_source'][cl], st_id, channel.azimuth, channel.dip]) if input_dics['bulk']: print('creating a list for bulk request...') bulk_list = [] for bulk_sta in sta_fdsn: if input_dics['cut_time_phase']: t_start, t_end = calculate_time_phase(event, bulk_sta) else: t_start = event['t1'] t_end = event['t2'] bulk_list.append((bulk_sta[0], bulk_sta[1], bulk_sta[2], bulk_sta[3], t_start, t_end)) bulk_list_fio = open(os.path.join( target_path, 'info', 'bulkdata_list_%s' % input_dics['data_source'][cl]), 'ab+') pickle.dump(bulk_list, bulk_list_fio, protocol=2) bulk_list_fio.close() except Exception as error: exc_file = open(os.path.join(target_path, 'info', 'exception'), 'at+') ee = 'availability -- %s -- %s\n' % (input_dics['data_source'][cl], error) exc_file.writelines(ee) exc_file.close() print('ERROR: %s' % ee) return [] if len(sta_fdsn) == 0: sta_fdsn = [] sta_fdsn.sort() return sta_fdsn
def FDSN_available(input_dics, event, target_path, event_number): """ Check the availablity of FDSN stations :param input_dics: :param event: :param target_path: :param event_number: :return: """ print "Check the availablity of FDSN stations: %s" \ % input_dics['fdsn_base_url'] client_fdsn = Client_fdsn(base_url=input_dics['fdsn_base_url'], user=input_dics['fdsn_user'], password=input_dics['fdsn_pass']) Sta_fdsn = [] try: if input_dics['fdsn_base_url'].lower() in ['resif']: # start_time = None # end_time = None start_time = event['t1'] end_time = event['t2'] else: start_time = event['t1'] end_time = event['t2'] available = client_fdsn.get_stations( network=input_dics['net'], station=input_dics['sta'], location=input_dics['loc'], channel=input_dics['cha'], starttime=start_time, endtime=end_time, latitude=input_dics['lat_cba'], longitude=input_dics['lon_cba'], minradius=input_dics['mr_cba'], maxradius=input_dics['Mr_cba'], minlatitude=input_dics['mlat_rbb'], maxlatitude=input_dics['Mlat_rbb'], minlongitude=input_dics['mlon_rbb'], maxlongitude=input_dics['Mlon_rbb'], level='channel') for network in available.networks: for station in network: for channel in station: Sta_fdsn.append([network.code, station.code, channel.location_code, channel.code, channel.latitude, channel.longitude, channel.elevation, channel.depth]) if input_dics['fdsn_bulk'] == 'Y': if input_dics['fdsn_update'] != 'N': if os.path.exists(os.path.join(target_path, 'info', 'bulkdata.txt')): os.remove(os.path.join(target_path, 'info', 'bulkdata.txt')) if os.path.exists(os.path.join(target_path, 'info', 'bulkdata.txt')): print 'bulkdata.txt exists in the directory!' else: print 'Start creating a list for bulk request' bulk_list = [] for bulk_sta in Sta_fdsn: if input_dics['cut_time_phase']: t_start, t_end = calculate_time_phase(event, bulk_sta) else: t_start = event['t1'] t_end = event['t2'] bulk_list.append((bulk_sta[0], bulk_sta[1], bulk_sta[2], bulk_sta[3], t_start, t_end)) bulk_list_fio = open(os.path.join(target_path, 'info', 'bulkdata_list'), 'a+') pickle.dump(bulk_list, bulk_list_fio) bulk_list_fio.close() except Exception as e: exc_file = open(os.path.join(target_path, 'info', 'exception'), 'a+') ee = 'fdsn -- Event: %s --- %s\n' % (str(event_number+1), e) exc_file.writelines(ee) exc_file.close() print 'ERROR: %s' % ee if len(Sta_fdsn) == 0: Sta_fdsn.append([]) Sta_fdsn.sort() return Sta_fdsn
#!/usr/bin/env python # -*- coding: utf-8 -*- from obspy.clients.fdsn import Client from obspy import UTCDateTime client = Client("IRIS") t = UTCDateTime("2010-02-27T06:45:00.000") inventory = client.get_stations(network="IC", station="BJT", location="00", channel="BH*", level="response", starttime=t) st = client.get_waveforms("IC", "BJT", "00", "BH*", t, t + 60 * 60) st.detrend(type="demean") # rmean st.detrend(type="linear") # rtrend st.taper(max_percentage=0.05) # taper # transfer to vel freq 0.005 0.01 10 25 st.remove_response(inventory=inventory, output="VEL", pre_filt=[0.005, 0.01, 10, 25]) # bandpass c 1 10 n 2 p 2 st.filter('bandpass', freqmin=0.01, freqmax=0.1, corners=2, zerophase=True) st.plot()
def test_seed_code_queries(self): client = FDSNClient(self.live_server_url) # First test some very specific queries. inv = client.get_stations(level="channel", network="BW", station="ALTM", location="--", channel="EH?") c = inv.get_contents() self.assertEqual(c["channels"], ['BW.ALTM..EHE', 'BW.ALTM..EHN', 'BW.ALTM..EHZ']) client = FDSNClient(self.live_server_url) inv = client.get_stations(level="channel", network="BW", station="ALTM", location="--", channel="EH*") c = inv.get_contents() self.assertEqual(c["channels"], ['BW.ALTM..EHE', 'BW.ALTM..EHN', 'BW.ALTM..EHZ']) client = FDSNClient(self.live_server_url) inv = client.get_stations(level="channel", network="BW", station="ALTM", location="", channel="EH*") c = inv.get_contents() self.assertEqual(c["channels"], ['BW.ALTM..EHE', 'BW.ALTM..EHN', 'BW.ALTM..EHZ']) client = FDSNClient(self.live_server_url) inv = client.get_stations(level="channel", network="B*", station="AL?M", location="*", channel="EH*") c = inv.get_contents() self.assertEqual(c["channels"], ['BW.ALTM..EHE', 'BW.ALTM..EHN', 'BW.ALTM..EHZ']) # Test exclusions. - First exclude things that don't exist in the # test database - should naturally still return everything. inv = client.get_stations(level="channel", network="-XX", station="-YY", location="-ZZ", channel="-BHE") c = inv.get_contents() self.assertEqual(c["channels"], ['BW.ALTM..EHE', 'BW.ALTM..EHN', 'BW.ALTM..EHZ']) inv = client.get_stations(level="channel", channel="-EHE") c = inv.get_contents() self.assertEqual(c["channels"], ['BW.ALTM..EHN', 'BW.ALTM..EHZ']) inv = client.get_stations(level="channel", channel="-EHE,-EHN") c = inv.get_contents() self.assertEqual(c["channels"], ['BW.ALTM..EHZ']) # A couple of no-datas with self.assertRaises(FDSNException): client.get_stations(network="TA", station="ALTM", location="--", channel="EH?") with self.assertRaises(FDSNException): client.get_stations(network="BW", station="FURT", location="--", channel="EH?") with self.assertRaises(FDSNException): client.get_stations(network="BW", station="ALTM", location="00", channel="EH?") with self.assertRaises(FDSNException): client.get_stations(network="BW", station="ALTM", location="--", channel="BHZ?")
starttime = UTCDateTime("2016-05-20") endtime = UTCDateTime("2016-05-22") cat = client.get_events(starttime=starttime, endtime=endtime, minmagnitude=2, limit=5, mindepth=5) print(type(cat)) #Catalog print(cat) cat.plot(outfile='output/py_eq_utc20160521_ml3.0_event.png') #add also resouces like: projection="local" #get stations with the event evt = cat[1] print(type(evt)) print(evt) origin = evt.origins[0] otime = origin.time print(type(origin)) t = origin.time inv = client.get_stations(longitude=origin.longitude, latitude=origin.latitude, maxradius=0.2, starttime=t, endtime =t+100, channel="HH?", network="CH", level="station") print(type(inv)) print(inv) inv.plot(projection="local", outfile='output/py_eq_utc20160521_ml3.0_station.png') #get the waveforms st = Stream() for network in inv: for station in network: try: st += client.get_waveforms(network.code, station.code, "*", "HH?", t - 5 * 60, t + 30 * 60, attach_response=True) except: pass #print(type(st)) #print(st) #st.select(component="Z").plot(bgcolor="#FF5733")
return ('mo') elif depth < 6.0: return ('yo') elif depth < 8.0: return ('go') elif depth < 10.0: return ('co') else: return ('bo') #---DATA_FROM_FDSN---# #fetch station:SIOM information client = Client(base_url = "http://arclink.ethz.ch", user='******', password='******') starttime = UTCDateTime("2014-01-01") endtime = UTCDateTime() inv = client.get_stations(network="CH", station="SIOM", starttime=starttime, endtime=endtime, level="station") #choose between other level, like: "network" "channel" "response" print(type(inv)) #Inventory print(inv) network = inv[0] print(network) station = network[0] print(station) #inv.plot(projection="local") centerlat = station.latitude centerlong = station.longitude #get specified event cat = client.get_events(starttime=starttime, endtime=endtime, latitude=centerlat, longitude=centerlong, maxradius=1, minmagnitude=1)#, filename="sion_events.xml") #print len(cat) evtnum = cat.count() print(type(cat)) #Catalog
class Concierge(object): """ ISPAQ Data Access Expediter. :type user_request: :class:`~ispaq.concierge.user_request` :param user_request: User request containing the combination of command-line arguments and information from the parsed user preferences file. :rtype: :class:`~ispaq.concierge` or ``None`` :return: ISPAQ Concierge. .. rubric:: Example TODO: include doctest examples """ def __init__(self, user_request=None, logger=None): """ Initializes the ISPAQ data access expediter. See :mod:`ispaq.concierge` for all parameters. """ # Keep the entire UserRequest and logger self.user_request = user_request self.logger = logger # Copy important UserRequest properties to the Concierge for smpler access self.requested_starttime = user_request.requested_starttime self.requested_endtime = user_request.requested_endtime self.metric_names = user_request.metrics self.sncl_patterns = user_request.sncls self.function_by_logic = user_request.function_by_logic self.logic_types = user_request.function_by_logic.keys() # Individual elements from the Preferences: section of the preferences file self.csv_output_dir = user_request.csv_output_dir self.plot_output_dir = user_request.plot_output_dir self.sigfigs = user_request.sigfigs # Output information file_base = '%s_%s_%s' % (self.user_request.requested_metric_set, self.user_request.requested_sncl_set, self.requested_starttime.date) self.output_file_base = self.csv_output_dir + '/' + file_base # Availability dataframe is stored if it is read from a local file self.availability = None # Filtered availability dataframe is stored for potential reuse self.filtered_availability = None # Add dataselect clients and URLs or reference a local file if user_request.dataselect_url in URL_MAPPINGS.keys(): # Get data from FDSN dataselect service self.dataselect_url = URL_MAPPINGS[user_request.dataselect_url] self.dataselect_client = Client(user_request.dataselect_url) else: if os.path.exists(os.path.abspath(user_request.dataselect_url)): # Get data from local miniseed files self.dataselect_url = os.path.abspath(user_request.dataselect_url) self.dataselect_client = None else: err_msg = "Cannot find preference file dataselect_url: '%s'" % user_request.dataselect_url self.logger.error(err_msg) raise ValueError(err_msg) # Add event clients and URLs or reference a local file if user_request.event_url in URL_MAPPINGS.keys(): self.event_url = URL_MAPPINGS[user_request.event_url] self.event_client = Client(user_request.event_url) else: if os.path.exists(os.path.abspath(user_request.event_url)): # Get data from local QUAKEML files self.event_url = os.path.abspath(user_request.event_url) self.event_client = None else: err_msg = "Cannot find preference file event_url: '%s'" % user_request.event_url self.logger.error(err_msg) raise ValueError(err_msg) # Add station clients and URLs or reference a local file if user_request.station_url in URL_MAPPINGS.keys(): self.station_url = URL_MAPPINGS[user_request.station_url] self.station_client = Client(user_request.station_url) else: if os.path.exists(os.path.abspath(user_request.station_url)): # Get data from local StationXML files self.station_url = os.path.abspath(user_request.station_url) self.station_client = None else: err_msg = "Cannot find preference file station_url: '%s'" % user_request.station_url self.logger.error(err_msg) raise ValueError(err_msg) def get_availability(self, network=None, station=None, location=None, channel=None, starttime=None, endtime=None, includerestricted=None, latitude=None, longitude=None, minradius=None, maxradius=None): """ ################################################################################ # getAvailability method returns a dataframe with information from the output # of the fdsn station web service with "format=text&level=channel". # With additional parameters, this webservice returns information on all # matching SNCLs that have available data. # # The fdsnws/station/availability web service will return space characters for location # codes that are SPACE SPACE. # # http://service.iris.edu/fdsnws/station/1/ # # #Network | Station | Location | Channel | Latitude | Longitude | Elevation | Depth | Azimuth | Dip | Instrument | Scale | ScaleFreq | ScaleUnits | SampleRate | StartTime | EndTime # CU|ANWB|00|LHZ|17.66853|-61.78557|39.0|0.0|0.0|-90.0|Streckeisen STS-2 Standard-gain|2.43609E9|0.05|M/S|1.0|2010-02-10T18:35:00|2599-12-31T23:59:59 # ################################################################################ if (!isGeneric("getAvailability")) { setGeneric("getAvailability", function(obj, network, station, location, channel, starttime, endtime, includerestricted, latitude, longitude, minradius, maxradius) { standardGeneric("getAvailability") }) } # END of R documentation Returns a dataframe of SNCLs available from the `station_url` source specified in the `user_request` object used to initialize the `Concierge`. By default, information in the `user_request` is used to generate a FDSN webservices request for station data. Where arguments are provided, these are used to override the information found in `user_request. :type network: str :param network: Select one or more network codes. Can be SEED network codes or data center defined codes. Multiple codes are comma-separated. :type station: str :param station: Select one or more SEED station codes. Multiple codes are comma-separated. :type location: str :param location: Select one or more SEED location identifiers. Multiple identifiers are comma-separated. As a special case ``"--"`` (two dashes) will be translated to a string of two space characters to match blank location IDs. :type channel: str :param channel: Select one or more SEED channel codes. Multiple codes are comma-separated. :type starttime: :class:`~obspy.core.utcdatetime.UTCDateTime` :param starttime: Limit to metadata epochs starting on or after the specified start time. :type endtime: :class:`~obspy.core.utcdatetime.UTCDateTime` :param endtime: Limit to metadata epochs ending on or before the specified end time. :type includerestricted: bool :param includerestricted: Specify if results should include information for restricted stations. :type latitude: float :param latitude: Specify the latitude to be used for a radius search. :type longitude: float :param longitude: Specify the longitude to the used for a radius search. :type minradius: float :param minradius: Limit results to stations within the specified minimum number of degrees from the geographic point defined by the latitude and longitude parameters. :type maxradius: float :param maxradius: Limit results to stations within the specified maximum number of degrees from the geographic point defined by the latitude and longitude parameters. #.. rubric:: Example #>>> my_request = UserRequest(dummy=True) #>>> concierge = Concierge(my_request) #>>> concierge.get_availability() #doctest: +ELLIPSIS #[u'US.OXF..BHE', u'US.OXF..BHN', u'US.OXF..BHZ'] """ # NOTE: Building the availability dataframe from a large StationXML is time consuming. # NOTE: If we are using local station data then we should only do this once. # Special case when using all defaults helps speed up any metrics making mutiple calls to get_availability if (network is None and station is None and location is None and channel is None and starttime is None and endtime is None and self.filtered_availability is not None): return(self.filtered_availability) # Read from a local StationXML file one time only if self.station_client is None: # Only read/parse if we haven't already done so if self.availability is None: try: self.logger.info("Reading StationXML file %s" % self.station_url) sncl_inventory = obspy.read_inventory(self.station_url) except Exception as e: err_msg = "The StationXML file: '%s' is not valid" % self.station_url self.logger.debug(e) self.logger.error(err_msg) raise ValueError(err_msg) self.logger.debug('Building availability dataframe...') # Set up empty dataframe df = pd.DataFrame(columns=("network", "station", "location", "channel", "latitude", "longitude", "elevation", "depth" , "azimuth", "dip", "instrument", "scale", "scalefreq", "scaleunits", "samplerate", "starttime", "endtime", "snclId")) # Walk through the Inventory object for n in sncl_inventory.networks: for s in n.stations: for c in s.channels: snclId = n.code + "." + s.code + "." + c.location_code + "." + c.code df.loc[len(df)] = [n.code, s.code, c.location_code, c.code, c.latitude, c.longitude, c.elevation, c.depth, c.azimuth, c.dip, c.sensor.description, None, # TODO: Figure out how to get instrument 'scale' None, # TODO: Figure out how to get instrument 'scalefreq' None, # TODO: Figure out how to get instrument 'scaleunits' c.sample_rate, c.start_date, c.end_date, snclId] # Save this dataframe internally self.logger.debug('Finished creating availability dataframe') self.availability = df # Container for all of the individual sncl_pattern dataframes generated sncl_pattern_dataframes = [] # Loop through all sncl_patterns --------------------------------------- for sncl_pattern in self.sncl_patterns: # Get "User Reqeust" parameters (UR_network, UR_station, UR_location, UR_channel) = sncl_pattern.split('.') # Allow arguments to override UserRequest parameters if starttime is None: _starttime = self.requested_starttime else: _starttime = starttime if endtime is None: _endtime = self.requested_endtime else: _endtime = endtime if network is None: _network = UR_network else: _network = network if station is None: _station = UR_station else: _station = station if location is None: _location = UR_location else: _location = location if channel is None: _channel = UR_channel else: _channel = channel _sncl_pattern = "%s.%s.%s.%s" % (_network,_station,_location,_channel) # Get availability dataframe --------------------------------------- if self.station_client is None: # Use internal dataframe df = self.availability else: # Read from FDSN web services try: sncl_inventory = self.station_client.get_stations(starttime=_starttime, endtime=_endtime, network=_network, station=_station, location=_location, channel=_channel, includerestricted=None, latitude=latitude, longitude=longitude, minradius=minradius, maxradius=maxradius, level="channel") except Exception as e: err_msg = "No sncls matching %s found at %s" % (_sncl_pattern, self.station_url) self.logger.debug(e) self.logger.warning(err_msg) continue self.logger.debug('Building availability dataframe...') # Set up empty dataframe df = pd.DataFrame(columns=("network", "station", "location", "channel", "latitude", "longitude", "elevation", "depth" , "azimuth", "dip", "instrument", "scale", "scalefreq", "scaleunits", "samplerate", "starttime", "endtime", "snclId")) # Walk through the Inventory object for n in sncl_inventory.networks: for s in n.stations: for c in s.channels: snclId = n.code + "." + s.code + "." + c.location_code + "." + c.code df.loc[len(df)] = [n.code, s.code, c.location_code, c.code, c.latitude, c.longitude, c.elevation, c.depth, c.azimuth, c.dip, c.sensor.description, None, # TODO: Figure out how to get instrument 'scale' None, # TODO: Figure out how to get instrument 'scalefreq' None, # TODO: Figure out how to get instrument 'scaleunits' c.sample_rate, c.start_date, c.end_date, snclId] # Subset availability dataframe based on _sncl_pattern ------------- # NOTE: This shouldn't be necessary for dataframes obtained from FDSN # NOTE: but it's quick so we always do it # Create python regex from _sncl_pattern # NOTE: Replace '.' first before introducing '.*' or '.'! py_pattern = _sncl_pattern.replace('.','\\.').replace('*','.*').replace('?','.') # Filter dataframe df = df[df.snclId.str.contains(py_pattern)] # Subset based on locally available data --------------------------- if self.dataselect_client is None: filename = '%s.%s.%s.%s.%s' % (_network, _station, _location, _channel, _starttime.strftime('%Y.%j')) filepattern = self.dataselect_url + '/' + filename + '*' # Allow for possible quality codes matching_files = glob.glob(filepattern) if (len(matching_files) == 0): err_msg = "No local waveforms matching %s" % filepattern self.logger.debug(err_msg) continue else: # Create a mask based on available file names mask = df.snclId.str.contains("MASK WITH ALL FALSE") for i in range(len(matching_files)): basename = os.path.basename(matching_files[i]) match = re.match('[^\\.]*\\.[^\\.]*\\.[^\\.]*\\.[^\\.]*',basename) sncl = match.group(0) py_pattern = sncl.replace('.','\\.') mask = mask | df.snclId.str.contains(py_pattern) # Subset based on the mask df = df[mask] # Append this dataframe if df.shape[0] == 0: self.logger.debug("No SNCLS found matching '%s'" % _sncl_pattern) else: sncl_pattern_dataframes.append(df) # END of sncl_patterns loop -------------------------------------------- if len(sncl_pattern_dataframes) == 0: err_msg = "No available waveforms matching" + str(self.sncl_patterns) self.logger.info(err_msg) raise NoAvailableDataError(err_msg) else: availability = pd.concat(sncl_pattern_dataframes, ignore_index=True) # TODO: remove duplicates if availability.shape[0] == 0: err_msg = "No available waveforms matching" + str(self.sncl_patterns) self.logger.info(err_msg) raise NoAvailableDataError(err_msg) else: # The concierge should remember this dataframe for metrics that # make multiple calls to get_availability with all defaults. self.filtered_availability = availability return availability def get_dataselect(self, network=None, station=None, location=None, channel=None, starttime=None, endtime=None, quality="B", inclusiveEnd=True, ignoreEpoch=False): """ Returns an R Stream that can be passed to metrics calculation methods. All arguments are required except for starttime and endtime. These arguments may be specified but will default to the time information found in the `user_request` used to generate a FDSN webservices request for MINIseed data. :type network: str :param network: Select one or more network codes. Can be SEED network codes or data center defined codes. Multiple codes are comma-separated. :type station: str :param station: Select one or more SEED station codes. Multiple codes are comma-separated. :type location: str :param location: Select one or more SEED location identifiers. Multiple identifiers are comma-separated. As a special case ``"--"`` (two dashes) will be translated to a string of two space characters to match blank location IDs. :type channel: str :param channel: Select one or more SEED channel codes. Multiple codes are comma-separated. :type starttime: :class:`~obspy.core.utcdatetime.UTCDateTime` :param starttime: Limit to metadata epochs starting on or after the specified start time. :type endtime: :class:`~obspy.core.utcdatetime.UTCDateTime` :param endtime: Limit to metadata epochs ending on or before the specified end time. """ # Allow arguments to override UserRequest parameters if starttime is None: _starttime = self.requested_starttime else: _starttime = starttime if endtime is None: _endtime = self.requested_endtime else: _endtime = endtime if self.dataselect_client is None: # Read local MINIseed file and convert to R_Stream filename = '%s.%s.%s.%s.%s' % (network, station, location, channel, _starttime.strftime('%Y.%j')) filepattern = self.dataselect_url + '/' + filename + '*' # Allow for possible quality codes matching_files = glob.glob(filepattern) if (len(matching_files) == 0): self.logger.info("No files found matching '%s'" % (filepattern)) else: filepath = matching_files[0] if (len(matching_files) > 1): self.logger.warning("Multiple files found matching" '%s -- using %s' % (filepattern, filepath)) try: # Get the ObsPy version of the stream py_stream = obspy.read(filepath) py_stream = py_stream.slice(_starttime, _endtime) # NOTE: ObsPy does not store state-of-health flags with each stream. # NOTE: We need to read them in separately from the miniseed file. flag_dict = obspy.io.mseed.util.get_timing_and_data_quality(filepath) act_flags = [0,0,0,0,0,0,0,0] # TODO: Find a way to read act_flags io_flags = [0,0,0,0,0,0,0,0] # TODO: Find a way to read io_flags dq_flags = flag_dict['data_quality_flags'] # NOTE: ObsPy does not store station metadata with each trace. # NOTE: We need to read them in separately from station metadata. availability = self.get_availability(network, station, location, channel, _starttime, _endtime) sensor = availability.instrument[0] scale = availability.scale[0] scalefreq = availability.scalefreq[0] scaleunits = availability.scaleunits[0] if sensor is None: sensor = "" # default from IRISSeismic Trace class prototype if scale is None: scale = 1.0 # default from IRISSeismic Trace class prototype if scalefreq is None: scalefreq = 1.0 # default from IRISSeismic Trace class prototype if scaleunits is None: scaleunits = "" # default from IRISSeismic Trace class prototype latitude = availability.latitude[0] longitude = availability.longitude[0] elevation = availability.elevation[0] depth = availability.depth[0] azimuth = availability.azimuth[0] dip = availability.dip[0] # Create the IRISSeismic version of the stream r_stream = irisseismic.R_Stream(py_stream, _starttime, _endtime, act_flags, io_flags, dq_flags, sensor, scale, scalefreq, scaleunits, latitude, longitude, elevation, depth, azimuth, dip) except Exception as e: err_msg = "Error reading in local waveform from %s" % filepath self.logger.debug(e) self.logger.error(err_msg) raise else: # Read from FDSN web services try: r_stream = irisseismic.R_getDataselect(self.dataselect_url, network, station, location, channel, _starttime, _endtime, quality, inclusiveEnd, ignoreEpoch) except Exception as e: err_msg = "Error reading in waveform from %s webservice" % self.dataselect_client self.logger.debug(e) self.logger.error(err_msg) raise # TODO: Do we need to test for valid R_Stream. if False: return None # TODO: raise an exception else: return r_stream def get_event(self, starttime=None, endtime=None, minmag=5.5, maxmag=None, magtype=None, mindepth=None, maxdepth=None): """ ################################################################################ # getEvent method returns seismic event data from the event webservice: # # http://service.iris.edu/fdsnws/event/1/ # # TODO: The getEvent method could be fleshed out with a more complete list # TODO: of arguments to be used as ws-event parameters. ################################################################################ # http://service.iris.edu/fdsnws/event/1/query?starttime=2013-02-01T00:00:00&endtime=2013-02-02T00:00:00&minmag=5&format=text # # #EventID | Time | Latitude | Longitude | Depth | Author | Catalog | Contributor | ContributorID | MagType | Magnitude | MagAuthor | EventLocationName # 4075900|2013-02-01T22:18:33|-11.12|165.378|10.0|NEIC|NEIC PDE|NEIC PDE-Q||MW|6.4|GCMT|SANTA CRUZ ISLANDS if (!isGeneric("getEvent")) { setGeneric("getEvent", function(obj, starttime, endtime, minmag, maxmag, magtype, mindepth, maxdepth) { standardGeneric("getEvent") }) } # END of R documentation Returns a dataframe of events returned by the `event_url` source specified in the `user_request` object used to initialize the `Concierge`. By default, information in the `user_request` is used to generate a FDSN webservices request for event data. Where arguments are provided, these are used to override the information found in `user_request. :type starttime: :class:`~obspy.core.utcdatetime.UTCDateTime` :param starttime: Limit to metadata epochs starting on or after the specified start time. :type endtime: :class:`~obspy.core.utcdatetime.UTCDateTime` :param endtime: Limit to metadata epochs ending on or before the specified end time. :type minmagnitude: float, optional :param minmagnitude: Limit to events with a magnitude larger than the specified minimum. :type maxmagnitude: float, optional :param maxmagnitude: Limit to events with a magnitude smaller than the specified maximum. :type magnitudetype: str, optional :param magnitudetype: Specify a magnitude type to use for testing the minimum and maximum limits. :type mindepth: float, optional :param mindepth: Limit to events with depth, in kilometers, larger than the specified minimum. :type maxdepth: float, optional :param maxdepth: Limit to events with depth, in kilometers, smaller than the specified maximum. #.. rubric:: Example #>>> my_request = UserRequest(dummy=True) #>>> concierge = Concierge(my_request) #>>> concierge.get_event() #doctest: +ELLIPSIS ' eventId time latitude longitude depth author...' """ # Allow arguments to override UserRequest parameters if starttime is None: _starttime = self.requested_starttime else: _starttime = starttime if endtime is None: _endtime = self.requested_endtime else: _endtime = endtime if self.event_client is None: # Read local QuakeML file try: event_catalog = obspy.read_events(self.event_url) except Exception as e: err_msg = "The StationXML file: '%s' is not valid." % self.station_url self.logger.debug(e) self.logger.error(err_msg) raise ValueError(err_msg) # events.columns # Index([u'eventId', u'time', u'latitude', u'longitude', u'depth', u'author', # u'cCatalog', u'contributor', u'contributorId', u'magType', u'magnitude', # u'magAuthor', u'eventLocationName'], # dtype='object') # dataframes = [] for event in event_catalog: origin = event.preferred_origin() magnitude = event.preferred_magnitude() df = pd.DataFrame({'eventId': re.sub('.*eventid=','',event.resource_id.id), 'time': origin.time, 'latitude': origin.latitude, 'longitude': origin.longitude, 'depth': origin.depth/1000, # IRIS event webservice returns depth in km # TODO: check this 'author': origin.creation_info.author, 'cCatalog': None, 'contributor': None, 'contributorId': None, 'magType': magnitude.magnitude_type, 'magnitude': magnitude.mag, 'magAuthor': magnitude.creation_info.author, 'eventLocationName': event.event_descriptions[0].text}, index=[0]) dataframes.append(df) # Concatenate into the events dataframe events = pd.concat(dataframes, ignore_index=True) else: # Read from FDSN web services # TODO: Need to make sure irisseismic.getEvent uses any FDSN site try: events = irisseismic.getEvent(starttime=_starttime, endtime=_endtime, minmag=minmag, maxmag=maxmag, magtype=magtype, mindepth=mindepth, maxdepth=maxdepth) except Exception as e: err_msg = "The event_url: '%s' returns an error" % (self.event_url) self.logger.debug(e) self.logger.error(err_msg) raise if events.shape[0] == 0: return None # TODO: raise an exception else: return events