def test_weekday(self): """ Tests weekday method. """ dt = UTCDateTime(2008, 10, 1, 12, 30, 35, 45020) self.assertEquals(dt.weekday, 2) self.assertEquals(dt._getWeekday(), 2)
def datetimefmt(origin): # 1999-01-31, 00:12:24.123 o = UTCDateTime(origin) o = UTCDateTime(round(o,3)) date = o.strftime("%Y-%m-%d") time = o.strftime("%H:%M:%S.%f")[0:12] return [date, time]
def test_toordinal(self): """ Short test if toordinal() is working. Matplotlib's date2num() function depends on this which is used a lot in plotting. """ dt = UTCDateTime("2012-03-04T11:05:09.123456Z") self.assertEquals(dt.toordinal(), 734566)
def DateTime2String(dt, compact=False): """ Generates a valid SEED time string from a UTCDateTime object. """ if isinstance(dt, UTCDateTime): return dt.formatSEED(compact) elif isinstance(dt, basestring): dt = dt.strip() if not dt: return "" try: dt = UTCDateTime(dt) return dt.formatSEED(compact) except: raise Exception("Invalid datetime %s: %s" % (type(dt), str(dt)))
def printOutput(output): output = output[1].split('\n') fob = open(logFilepath, 'a') for line in output: if 'cal found' in line: fob.write(line + '\n') fob.write(str(UTCDateTime.now())) fob.close()
def test_toPythonDateTimeObjects(self): """ Tests getDate, getTime, getTimestamp and getDateTime methods. """ dt = UTCDateTime(1970, 1, 1, 12, 23, 34, 456789) # as function self.assertEquals(dt._getDate(), datetime.date(1970, 1, 1)) self.assertEquals(dt._getTime(), datetime.time(12, 23, 34, 456789)) self.assertEquals(dt._getDateTime(), datetime.datetime(1970, 1, 1, 12, 23, 34, 456789)) self.assertAlmostEquals(dt._getTimeStamp(), 44614.456789) # as property self.assertEquals(dt.date, datetime.date(1970, 1, 1)) self.assertEquals(dt.time, datetime.time(12, 23, 34, 456789)) self.assertEquals(dt.datetime, datetime.datetime(1970, 1, 1, 12, 23, 34, 456789)) self.assertAlmostEquals(dt.timestamp, 44614.456789)
def main(): stations = 'PB01 PB02 PB03 PB04 PB05' component = 'Z' t1 = UTC('2009-06-01') t2 = UTC('2009-07-01') data = IPOC('test', use_local_LVC=False) data.setXLogger('_test') period = 24 * 3600 ax = None plt.ion() for station in stations.split(): pxxs = [] freqs_old = None i = 0 for t in timegen(t1, t2, period): st = data.getRawStreamFromClient(t, t + period, station, component) st.merge(method=1, interpolation_samples=10, fill_value='interpolate') print st pxx, freqs = st.plotPSD(just_calculate=True) assert np.all(freqs == freqs_old) or not freqs_old freqs_old = freqs if max(pxx[4:]) > 1e7: print 'discard' i += 1 continue pxxs.append(pxx) pxx = sum(pxxs) / len(pxxs) del pxxs tr = Trace(data=pxx, header=dict(is_fft=True, sampling_rate=2 * max(freqs), freq_min=min(freqs), freq_max=max(freqs))) ax = tr.plotPSD(ax=ax, label='%s-%d' % (st[0].stats.station, i), figtitle=None) plt.draw() # embed() ax.legend() fig = ax.get_figure() fig.suptitle('%s %s %s to %s' % (stations, component, t1.strftime('%Y-%m-%d'), t2.strftime('%Y-%m-%d'))) plt.ioff() plt.show()
def checkNetsta(netsta): global network, station network, station = netsta.split('/')[-1].split('_') #sets up the commands for running addNewCals for given years and stations for year in xrange(int(byear), int(eyear) + 1): #if the year is the beginning year and not the ending year if year == int(byear) and year != int(eyear): print str(UTCDateTime.now()).split('.')[0].replace('T',' '), 'Checking', network, station.ljust(4), year, bjday, '- 366', 'for calibrations' #starting on the beginning day and ending at the end of the current year for day in xrange(int(bjday), 366 + 1): output = commands.getstatusoutput('python ./addNewCals.py -n ' + network + ' -s ' + station + ' -d ' + str(year) + ',' + str(day).zfill(3))[1] #if there is a calibration, proceed if output != '': print output #if the year is in between the beginning year and ending year elif int(byear) < year < int(eyear): print str(UTCDateTime.now()).split('.')[0].replace('T',' '), 'Checking', network, station.ljust(4), year, '001 - 366', 'for calibrations' #proceed from day 001 to day 366 for day in xrange(1, 366 + 1): ouput = commands.getstatusoutput('python ./addNewCals.py -n ' + network + ' -s ' + station + ' -d ' + str(year) + ',' + str(day).zfill(3))[1] #if there is a calibration, proceed if output != '': print output #if the year is the ending year and not the beginning year elif year == int(eyear) and year != int(byear): print str(UTCDateTime.now()).split('.')[0].replace('T',' '), 'Checking', network, station.ljust(4), year, '001 -', ejday, 'for calibrations' #proceed form day 001 to the ending day for day in xrange(1, int(ejday) + 1): output = commands.getstatusoutput('python ./addNewCals.py -n ' + network + ' -s ' + station + ' -d ' + str(year) + ',' + str(day).zfill(3))[1] #if there is a calibration, proceed if output != '': print output #if the year is the beginning year and ending year elif year == int(byear) == int(eyear): print str(UTCDateTime.now()).split('.')[0].replace('T',' '), 'Checking', network, station.ljust(4), year, bjday, '-', ejday, 'for calibrations' #proceed from the beginning day to the ending day for day in xrange(int(bjday), int(ejday) + 1): output = commands.getstatusoutput('python ./addNewCals.py -n ' + network + ' -s ' + station + ' -d ' + str(year) + ',' + str(day).zfill(3))[1] #if there is a calibration, proceed if output != '': print output
def get_calibrations(file_name): calibrations = [] #Read the first file and get the record length from blockette 1000 fh = open(file_name, 'rb') record = fh.read(256) index = struct.unpack('>H', record[46:48])[0] file_stats = os.stat(file_name) record_length = 2 ** struct.unpack('>B', record[index+6:index+7])[0] #Get the total number of records total_records = file_stats[stat.ST_SIZE] / record_length #Now loop through the records and look for calibration blockettes for rec_idx in xrange(0,total_records): fh.seek(rec_idx * record_length,0) record = fh.read(record_length) next_blockette = struct.unpack('>H', record[46:48])[0] while next_blockette != 0: index = next_blockette blockette_type, next_blockette = struct.unpack('>HH', record[index:index+4]) if blockette_type in (300, 310, 320, 390): if debug: print 'We have a calibration blockette' year,jday,hour,minute,sec,_,tmsec,_,cal_flags,duration = tuple(struct.unpack('>HHBBBBHBBL', record[index+4:index+20])) stime = UTCDateTime(year=year,julday=jday,hour=hour,minute=minute,second=sec) if debug: print(stime.ctime()) if blockette_type == 300: step_count,_,_,ntrvl_duration,amplitude,cal_input = struct.unpack('>BBLLf3s', record[index+14:index+31]) calibrations.append({'type':'step','amplitude': amplitude,'number':step_count,'start_time':stime,'duration':duration/10000,'inteveral_duration':ntrvl_duration}) if blockette_type == 310: signal_period,amplitude,cal_input = struct.unpack('>ff3s', record[index+20:index+31]) calibrations.append({'type':'sine','amplitude': amplitude, 'period': signal_period,'start_time':stime,'duration':duration/10000}) if blockette_type in (320, 390): amplitude,cal_input = struct.unpack('>f3s', record[index+20:index+27]) calibrations.append({'type':'random','amplitude': amplitude,'start_time':stime,'duration':duration/10000}) fh.close() return calibrations
def plot_graph(self): now = UTCDateTime() if self.drum_plot: self.stop_time = UTCDateTime( now.year, now.month, now.day, now.hour, 0, 0) + 3600 self.start_time = self.stop_time - self.args.backtrace_time else: self.start_time = now - self.backtrace self.stop_time = now with self.lock: # leave some data left of our start for possible processing self.stream.trim( starttime=self.start_time - 120, nearest_sample=False) stream = self.stream.copy() try: logging.info(str(stream.split())) if not stream: raise Exception("Empty stream for plotting") if self.drum_plot or OBSPY_VERSION < [0, 10]: stream.merge() stream.trim(starttime=self.start_time, endtime=self.stop_time, pad=True, nearest_sample=False) else: stream.merge(-1) stream.trim(starttime=self.start_time, endtime=self.stop_time) if self.drum_plot: self.plot_drum(stream) else: self.plot_lines(stream) except Exception as e: logging.error(e) pass self.after(int(self.args.update_time * 1000), self.plot_graph)
fault_name = 'nepal.fault' #Fault geometry station_file = 'nepal.sta' #Station distribution GF_list = 'gps.gflist' #What GFs are to be computed for each station G_from_file = False G_name = 'nepal' NFFT = 512 dt = 0.2 #Time parameters dk = 0.2 pmin = 0 pmax = 1 kmax = 10 #fk integration parameters custom_stf = None ################################################################################ ############ Synthetics parameters ############### time_epi = UTCDateTime('2015-04-25T06:11:26') epicenter = array([84.708, 28.147, 15]) resample = None #Resample synthetics to this rate (in Hz) integrate = 0 #=0 produces velocities, =1 makes displacements beta = 0 #Rake offset, usually a good idea to keep at zero num_windows = 1 rupture_speed = 3.0 #Only necessary if onset times are not identified in rupt file stf_type = 'dreger' ################################################################################ #Initalize project folders if init == 1: runslip.init(home, project_name) # Run green functions if make_green == 1:
def test_getEventsList(self): """ Testing event request method. """ client = Client() # 1 results = client.getEvents(format="list", min_depth=-700, max_datetime="2005-01-01") expected = [{ 'author': u'EMSC', 'event_id': u'20040312_0000026', 'origin_id': 1347097, 'longitude': 57.143, 'datetime': UTCDateTime('2004-03-12T22:48:05Z'), 'depth': -700.0, 'magnitude': 4.4, 'magnitude_type': u'mb', 'latitude': 26.303, 'flynn_region': u'SOUTHERN IRAN' }] self.assertEquals(results, expected) # 2 results = client.getEvents(format="list", min_latitude=-95, max_latitude=-1, min_longitude=20, max_longitude=90, max_datetime="2005-01-01") expected = [{ 'author': u'NEIR', 'event_id': u'20041016_0000009', 'origin_id': 120690, 'longitude': 33.682, 'datetime': UTCDateTime('2004-10-16T01:29:14Z'), 'depth': -10.0, 'magnitude': 5.0, 'magnitude_type': u'm ', 'latitude': -46.394, 'flynn_region': u'PRINCE EDWARD ISLANDS REGION' }] self.assertEquals(results, expected) # 3 results = client.getEvents(format="list", min_depth=-11, max_depth=-22.33, min_magnitude=6.6, max_magnitude=7, max_datetime="2005-01-01") expected = [{ 'author': u'EMSC', 'event_id': u'20001206_0000014', 'origin_id': 1441886, 'longitude': 54.843, 'datetime': UTCDateTime('2000-12-06T17:11:05Z'), 'depth': -11.4, 'magnitude': 6.7, 'magnitude_type': u'mb', 'latitude': 39.604 }, { 'author': u'EMSC', 'event_id': u'20010210_0000010', 'origin_id': 1438991, 'longitude': 43.784, 'datetime': UTCDateTime('2001-02-10T18:21:57Z'), 'depth': -17.0, 'magnitude': 6.6, 'magnitude_type': u'mb', 'latitude': 12.045, 'flynn_region': u'NEAR THE COAST OF YEMEN' }] self.assertEquals(results, expected) # 4 results = client.getEvents(format="list", author="EMSC", max_results=3, magnitude_type="mw", min_magnitude=4, max_datetime="2005-01-01") expected = [{ 'author': u'EMSC', 'event_id': u'19980110_0000006', 'origin_id': 1500183, 'longitude': 20.816, 'datetime': UTCDateTime('1998-01-10T19:21:55Z'), 'depth': -10.0, 'magnitude': 5.5, 'magnitude_type': u'mw', 'latitude': 37.243, 'flynn_region': u'IONIAN SEA' }, { 'author': u'EMSC', 'event_id': u'19980128_0000006', 'origin_id': 1500249, 'longitude': 32.204, 'datetime': UTCDateTime('1998-01-28T22:38:57Z'), 'depth': -41.6, 'magnitude': 4.3, 'magnitude_type': u'mw', 'latitude': 34.429 }, { 'author': u'EMSC', 'event_id': u'19980213_0000004', 'origin_id': 1500135, 'longitude': 28.459, 'datetime': UTCDateTime('1998-02-13T07:18:50Z'), 'depth': -69.2, 'magnitude': 4.8, 'magnitude_type': u'mw', 'latitude': 36.284 }] self.assertEquals(results, expected)
#%% User-defined parameters from waveform_collection import gather_waveforms from obspy.core import UTCDateTime import numpy as np # Data collection SOURCE = 'IRIS' NETWORK = 'IM' STATION = 'I53H?' LOCATION = '*' CHANNEL = '*' START = UTCDateTime('2018-12-19T01:45:00') END = START + 20*60 # Filtering FMIN = 0.1 # [Hz] FMAX = 1 # [Hz] # Array processing WINLEN = 50 # [s] WINOVER = 0.5 #%% Grab and filter waveforms st = gather_waveforms(SOURCE, NETWORK, STATION, LOCATION, CHANNEL, START, END, remove_response=True) st.filter('bandpass', freqmin=FMIN, freqmax=FMAX, corners=2, zerophase=True) st.taper(max_percentage=0.01)
from obspy.signal import PPSD from obspy.clients.fdsn.client import Client import glob import matplotlib.pyplot as plt from obspy.signal.spectral_estimation import get_nlnm, get_nhnm import matplotlib as mpl mpl.rc('font', family='serif') mpl.rc('font', serif='Times') mpl.rc('text', usetex=True) mpl.rc('font', size=18) debug = True sta = 'ALQ' net = "DW" stime = UTCDateTime('1981-001T00:00:00.0') etime = UTCDateTime('1982-365T00:00:00.0') #client=Client() #inv = client.get_stations(network=net, station=sta, starttime=stime, endtime=etime, channel="*", level='response') #for chan in ['LHZ', 'LHN', 'LHE', 'SHZ']: #files = glob.glob("/msd/DW_ALQ/*/*/_" + chan + '*') #for curfile in files: #st = read(curfile) #if 'ppsd' not in vars(): #ppsd = PPSD(st[0].stats, inv, period_smoothing_width_octaves=0.5) #if debug: #print(curfile)
#!/usr/bin/env python import argparse import commands import glob from multiprocessing import Pool from obspy.core import UTCDateTime #initializes the variables now = UTCDateTime.now() net = '' network = '' sta = '' station = '' bdate = '' byear = '' bjday = '' edate = '' eyear = '' ejday = '' def main(): #main sequence of logic arguments = getArguments() setArguments(arguments) checkDates() print 'DONE' def getArguments(): #This function parses the command line arguments
network = getParam(args,'net',msgLib,None) station = getParam(args,'sta',msgLib,None) location = staLib.getLocation(getParam(args,'loc',msgLib,None)) channel = getParam(args,'chan',msgLib,None) if len(channel) <3: channel += "*" # # PSD files are all HOURLY files with 50% overlap computed as part of the polarization product # date parameter of the hourly PSDs to start, it starts at hour 00:00:00 # - HOURLY files YYYY-MM-DD # dataDirectory = param.dataDirectory startDateTime = getParam(args,'start',msgLib,None).split("T")[0] # we always want to start from the begining of the day, so we discard user hours, if any startDateTime += "T00:00:00" tStart = UTCDateTime(startDateTime) startYear = tStart.strftime("%Y") startMonth = tStart.strftime("%m") startDay = tStart.strftime("%d") startDOY = tStart.strftime("%j") endDateTime = getParam(args,'end',msgLib,None).split("T")[0] # we always want to start from the begining of the day, so we discard user hours, if any endDateTime += "T00:00:00" # endDateTime is included tEnd = UTCDateTime(endDateTime)+86400 endYear = tEnd.strftime("%Y") endMonth = tEnd.strftime("%m") endDay = tEnd.strftime("%d") endDOY = tEnd.strftime("%j") duration = tEnd - tStart dEnd = date(int(endYear),int(endMonth),int(endDay)) dStart = date(int(startYear),int(startMonth),int(startDay))
class WaveformPlotting(object): """ Class that provides several solutions for plotting large and small waveform data sets. .. warning:: This class should NOT be used directly, instead use the :meth:`~obspy.core.stream.Stream.plot` method of the ObsPy :class:`~obspy.core.stream.Stream` or :class:`~obspy.core.trace.Trace` objects. It uses matplotlib to plot the waveforms. """ def __init__(self, **kwargs): """ Checks some variables and maps the kwargs to class variables. """ self.stream = kwargs.get('stream') # Check if it is a Stream or a Trace object. if isinstance(self.stream, Trace): self.stream = Stream([self.stream]) elif not isinstance(self.stream, Stream): msg = 'Plotting is only supported for Stream or Trace objects.' raise TypeError(msg) # Stream object should contain at least one Trace if len(self.stream) < 1: msg = "Empty object" raise IndexError(msg) # Type of the plot. self.type = kwargs.get('type', 'normal') # Start- and endtimes of the plots. self.starttime = kwargs.get('starttime', None) self.endtime = kwargs.get('endtime', None) self.fig_obj = kwargs.get('fig', None) # If no times are given take the min/max values from the stream object. if not self.starttime: self.starttime = min([trace.stats.starttime for \ trace in self.stream]) if not self.endtime: self.endtime = max([trace.stats.endtime for \ trace in self.stream]) # Map stream object and slice just in case. self.stream = self.stream.slice(self.starttime, self.endtime) # normalize times if self.type == 'relative': dt = self.starttime # fix plotting boundaries self.endtime = UTCDateTime(self.endtime - self.starttime) self.starttime = UTCDateTime(0) # fix stream times for tr in self.stream: tr.stats.starttime = UTCDateTime(tr.stats.starttime - dt) # Whether to use straight plotting or the fast minmax method. self.plotting_method = kwargs.get('method', 'fast') # Below that value the data points will be plotted normally. Above it # the data will be plotted using a different approach (details see # below). Can be overwritten by the above self.plotting_method kwarg. self.max_npts = 400000 # If automerge is enabled. Merge traces with the same id for the plot. self.automerge = kwargs.get('automerge', True) # Set default values. # The default value for the size is determined dynamically because # there might be more than one channel to plot. self.size = kwargs.get('size', None) # Values that will be used to calculate the size of the plot. self.default_width = 800 self.default_height_per_channel = 250 if not self.size: self.width = 800 # Check the kind of plot. if self.type == 'dayplot': self.height = 600 else: # One plot for each trace. if self.automerge: count = [] for tr in self.stream: if hasattr(tr.stats, 'preview') and tr.stats.preview: tr_id = tr.id + 'preview' else: tr_id = tr.id if not tr_id in count: count.append(tr_id) count = len(count) else: count = len(self.stream) self.height = count * 250 else: self.width, self.height = self.size # Interval length in minutes for dayplot. self.interval = 60 * kwargs.get('interval', 15) # Scaling. self.vertical_scaling_range = kwargs.get('vertical_scaling_range', None) # Dots per inch of the plot. Might be useful for printing plots. self.dpi = kwargs.get('dpi', 100) # Color of the graph. if self.type == 'dayplot': self.color = kwargs.get('color', ('#000000','#B2000F', '#004C12', '#0E01FF')) if isinstance(self.color, basestring): self.color = (self.color,) self.number_of_ticks = kwargs.get('number_of_ticks', None) else: self.color = kwargs.get('color', 'k') self.number_of_ticks = kwargs.get('number_of_ticks', 5) # Background and face color. self.background_color = kwargs.get('bgcolor', 'w') self.face_color = kwargs.get('face_color', 'w') # Transparency. Overwrites background and facecolor settings. self.transparent = kwargs.get('transparent', False) if self.transparent: self.background_color = None # Ticks. self.tick_format = kwargs.get('tick_format', '%H:%M:%S') self.tick_rotation = kwargs.get('tick_rotation', 0) # Whether or not to save a file. self.outfile = kwargs.get('outfile') self.handle = kwargs.get('handle') # File format of the resulting file. Usually defaults to PNG but might # be dependent on your matplotlib backend. self.format = kwargs.get('format') def plotWaveform(self, *args, **kwargs): """ Creates a graph of any given ObsPy Stream object. It either saves the image directly to the file system or returns an binary image string. For all color values you can use legit HTML names, HTML hex strings (e.g. '#eeefff') or you can pass an R , G , B tuple, where each of R , G , B are in the range [0, 1]. You can also use single letters for basic built-in colors ('b' = blue, 'g' = green, 'r' = red, 'c' = cyan, 'm' = magenta, 'y' = yellow, 'k' = black, 'w' = white) and gray shades can be given as a string encoding a float in the 0-1 range. """ # Setup the figure if not passed explicitly. if not self.fig_obj: self.__setupFigure() else: self.fig = self.fig_obj # Determine kind of plot and do the actual plotting. if self.type == 'dayplot': self.plotDay(*args, **kwargs) else: self.plot(*args, **kwargs) # Adjust the subplot so there is always a margin of 80 px on every # side except for plots with just a single trace. if self.type != 'dayplot': if self.height >= 400: fract_y = 80.0 / self.height else: fract_y = 25.0 / self.height fract_x = 80.0 / self.width self.fig.subplots_adjust(top=1.0 - fract_y, bottom=fract_y, left=fract_x, right=1 - fract_x) self.fig.canvas.draw() # The following just serves as a unified way of saving and displaying # the plots. if not self.transparent: extra_args = {'dpi': self.dpi, 'facecolor': self.face_color, 'edgecolor': self.face_color} else: extra_args = {'dpi': self.dpi, 'transparent': self.transparent} if self.outfile: # If format is set use it. if self.format: self.fig.savefig(self.outfile, format=self.format, **extra_args) # Otherwise use format from self.outfile or default to PNG. else: self.fig.savefig(self.outfile, **extra_args) else: # Return an binary imagestring if not self.outfile but self.format. if self.format: imgdata = StringIO.StringIO() self.fig.savefig(imgdata, format=self.format, **extra_args) imgdata.seek(0) return imgdata.read() elif self.handle: return self.fig else: if not self.fig_obj: plt.show() def plot(self, *args, **kwargs): """ Plot the Traces showing one graph per Trace. Plots the whole time series for self.max_npts points and less. For more points it plots minmax values. """ stream_new = [] # Just remove empty traces. if not self.automerge: for tr in self.stream: stream_new.append([]) if len(tr.data): stream_new[-1].append(tr) else: # Generate sorted list of traces (no copy) # Sort order, id, starttime, endtime ids = [] for tr in self.stream: if hasattr(tr.stats, 'preview') and tr.stats.preview: id = tr.id + 'preview' else: id = tr.id if not id in ids: ids.append(id) for id in ids: stream_new.append([]) for tr in self.stream: if hasattr(tr.stats, 'preview') and tr.stats.preview: tr_id = tr.id + 'preview' else: tr_id = tr.id if tr_id == id: # does not copy the elements of the data array tr_ref = copy(tr) # Trim does nothing if times are outside if self.starttime >= tr_ref.stats.endtime or \ self.endtime <= tr_ref.stats.starttime: continue if tr_ref.data.size: stream_new[-1].append(tr_ref) # delete if empty list if not len(stream_new[-1]): stream_new.pop() continue stream_new[-1].sort(key=lambda x: x.stats.endtime) stream_new[-1].sort(key=lambda x: x.stats.starttime) # If everything is lost in the process raise an Exception. if not len(stream_new): raise Exception("Nothing to plot") # Create helper variable to track ids and min/max/mean values. self.stats = [] # Loop over each Trace and call the appropriate plotting method. self.axis = [] for _i, tr in enumerate(stream_new): # Each trace needs to have the same sampling rate. sampling_rates = set([_tr.stats.sampling_rate for _tr in tr]) if len(sampling_rates) > 1: msg = "All traces with the same id need to have the same " + \ "sampling rate." raise Exception(msg) sampling_rate = sampling_rates.pop() if self.background_color: ax = self.fig.add_subplot(len(stream_new), 1, _i + 1, axisbg=self.background_color) else: ax = self.fig.add_subplot(len(stream_new), 1, _i + 1) self.axis.append(ax) # XXX: Also enable the minmax plotting for previews. if self.plotting_method != 'full' and \ ((self.endtime - self.starttime) * sampling_rate > \ self.max_npts): self.__plotMinMax(stream_new[_i], ax, *args, **kwargs) else: self.__plotStraight(stream_new[_i], ax, *args, **kwargs) # Set ticks. self.__plotSetXTicks() self.__plotSetYTicks() def plotDay(self, *args, **kwargs): """ Extend the seismogram. """ # Create a copy of the stream because it might be operated on. self.stream = self.stream.copy() # Merge and trim to pad. self.stream.merge() if len(self.stream) != 1: msg = "All traces need to be of the same id for a dayplot" raise ValueError(msg) self.stream.trim(self.starttime, self.endtime, pad=True) # Get minmax array. self.__dayplotGetMinMaxValues(self, *args, **kwargs) # Normalize array self.__dayplotNormalizeValues(self, *args, **kwargs) # Get timezone information. If none is given, use local time. self.time_offset = kwargs.get('time_offset', round((UTCDateTime(datetime.now()) - \ UTCDateTime()) / 3600.0, 2)) self.timezone = kwargs.get('timezone', 'local time') # Try to guess how many steps are needed to advance one full time unit. self.repeat = None intervals = self.extreme_values.shape[0] if self.interval < 60 and 60 % self.interval == 0: self.repeat = 60 / self.interval elif self.interval < 1800 and 3600 % self.interval == 0: self.repeat = 3600 / self.interval # Otherwise use a maximum value of 10. else: if intervals >= 10: self.repeat = 10 else: self.repeat = intervals # Create axis to plot on. if self.background_color: ax = self.fig.add_subplot(1, 1, 1, axisbg=self.background_color) else: ax = self.fig.add_subplot(1, 1, 1) # Adjust the subplots to be symmetrical. Also make some more room # at the top. self.fig.subplots_adjust(left=0.12, right=0.88, top=0.88) # Create x_value_array. aranged_array = np.arange(self.width) x_values = np.empty(2 * self.width) x_values[0::2] = aranged_array x_values[1::2] = aranged_array intervals = self.extreme_values.shape[0] # Loop over each step. for _i in xrange(intervals): # Create offset array. y_values = np.ma.empty(self.width * 2) y_values.fill(intervals - (_i + 1)) # Add min and max values. y_values[0::2] += self.extreme_values[_i, :, 0] y_values[1::2] += self.extreme_values[_i, :, 1] # Plot the values. ax.plot(x_values, y_values, color=self.color[_i % len(self.color)]) # Set ranges. ax.set_xlim(0, self.width - 1) ax.set_ylim(-0.3, intervals + 0.3) self.axis = [ax] # Set ticks. self.__dayplotSetYTicks() self.__dayplotSetXTicks() # Choose to show grid but only on the x axis. self.fig.axes[0].grid() self.fig.axes[0].yaxis.grid(False) # Set the title of the plot. #suptitle = '%s %s'%(self.stream[0].id,self.starttime.strftime('%Y-%m-%d')) #self.fig.suptitle(suptitle, fontsize='small') def __plotStraight(self, trace, ax, *args, **kwargs): # @UnusedVariable """ Just plots the data samples in the self.stream. Useful for smaller datasets up to around 1000000 samples (depending on the machine its being run on). Slow and high memory consumption for large datasets. """ # Copy to avoid any changes to original data. trace = deepcopy(trace) if len(trace) > 1: stream = Stream(traces=trace) # Merge with 'interpolation'. In case of overlaps this method will # always use the longest available trace. if hasattr(trace[0].stats, 'preview') and trace[0].stats.preview: stream = Stream(traces=stream) stream = mergePreviews(stream) else: stream.merge(method=1) trace = stream[0] else: trace = trace[0] # Check if it is a preview file and adjust accordingly. # XXX: Will look weird if the preview file is too small. if hasattr(trace.stats, 'preview') and trace.stats.preview: # Mask the gaps. trace.data = np.ma.masked_array(trace.data) trace.data[trace.data == -1] = np.ma.masked # Recreate the min_max scene. dtype = trace.data.dtype old_time_range = trace.stats.endtime - trace.stats.starttime data = np.empty(2 * trace.stats.npts, dtype=dtype) data[0::2] = trace.data / 2.0 data[1::2] = -trace.data / 2.0 trace.data = data # The times are not supposed to change. trace.stats.delta = old_time_range / float(trace.stats.npts - 1) # Write to self.stats. calib = trace.stats.calib max = trace.data.max() min = trace.data.min() if hasattr(trace.stats, 'preview') and trace.stats.preview: tr_id = trace.id + ' [preview]' else: tr_id = trace.id self.stats.append([tr_id, calib * trace.data.mean(), calib * min, calib * max]) # Pad the beginning and the end with masked values if necessary. Might # seem like overkill but it works really fast and is a clean solution # to gaps at the beginning/end. concat = [trace] if self.starttime != trace.stats.starttime: samples = (trace.stats.starttime - self.starttime) * \ trace.stats.sampling_rate temp = [np.ma.masked_all(int(samples))] concat = temp.extend(concat) concat = temp if self.endtime != trace.stats.endtime: samples = (self.endtime - trace.stats.endtime) * \ trace.stats.sampling_rate concat.append(np.ma.masked_all(int(samples))) if len(concat) > 1: # Use the masked array concatenate, otherwise it will result in a # not masked array. trace.data = np.ma.concatenate(concat) # set starttime and calculate endtime trace.stats.starttime = self.starttime trace.data *= calib ax.plot(trace.data, color=self.color) # Set the x limit for the graph to also show the masked values at the # beginning/end. ax.set_xlim(0, len(trace.data) - 1) def __plotMinMax(self, trace, ax, *args, **kwargs): # @UnusedVariable """ Plots the data using a min/max approach that calculated the minimum and maximum values of each "pixel" and than plots only these values. Works much faster with large data sets. """ # Some variables to help calculate the values. starttime = self.starttime.timestamp endtime = self.endtime.timestamp # The same trace will always have the same sampling_rate. sampling_rate = trace[0].stats.sampling_rate # The samples per resulting pixel. pixel_length = int((endtime - starttime) / self.width * sampling_rate) # Loop over all the traces. Do not merge them as there are many samples # and therefore merging would be slow. for _i, _t in enumerate(trace): # Get the start of the next pixel in case the starttime of the # trace does not match the starttime of the plot. ts = _t.stats.starttime if ts > self.starttime: start = int(ceil(((ts - self.starttime) * \ sampling_rate) / pixel_length)) # Samples before start. prestart = int(((self.starttime + start * pixel_length / sampling_rate) - ts) * sampling_rate) else: start = 0 prestart = 0 # Figure out the number of pixels in the current trace. length = len(_t.data) - prestart pixel_count = int(length // pixel_length) rest = int(length % pixel_length) # Reference to new data array which does not copy data but is # reshapeable. data = _t.data[prestart: prestart + pixel_count * pixel_length] data = data.reshape(pixel_count, pixel_length) # Calculate extreme_values and put them into new array. extreme_values = np.ma.masked_all((self.width, 2), dtype=np.float) min = data.min(axis=1) * _t.stats.calib max = data.max(axis=1) * _t.stats.calib extreme_values[start: start + pixel_count, 0] = min extreme_values[start: start + pixel_count, 1] = max # First and last and last pixel need separate treatment. if start and prestart: extreme_values[start - 1, 0] = \ _t.data[:prestart].min() * _t.stats.calib extreme_values[start - 1, 1] = \ _t.data[:prestart].max() * _t.stats.calib if rest: if start + pixel_count == self.width: index = self.width - 1 else: index = start + pixel_count extreme_values[index, 0] = \ _t.data[-rest:].min() * _t.stats.calib extreme_values[index, 1] = \ _t.data[-rest:].max() * _t.stats.calib # Use the first array as a reference and merge all following # extreme_values into it. if _i == 0: minmax = extreme_values else: # Merge minmax and extreme_values. min = np.ma.empty((self.width, 2)) max = np.ma.empty((self.width, 2)) # Fill both with the values. min[:, 0] = minmax[:, 0] min[:, 1] = extreme_values[:, 0] max[:, 0] = minmax[:, 1] max[:, 1] = extreme_values[:, 1] # Find the minimum and maximum values. min = min.min(axis=1) max = max.max(axis=1) # Write again to minmax. minmax[:, 0] = min minmax[:, 1] = max # Write to self.stats. self.stats.append([trace[0].id, minmax.mean(), minmax[:, 0].min(), minmax[:, 1].max()]) # Finally plot the data. x_values = np.empty(2 * self.width) aranged = np.arange(self.width) x_values[0::2] = aranged x_values[1::2] = aranged # Initialize completely masked array. This version is a little bit # slower than first creating an empty array and then setting the mask # to True. But on NumPy 1.1 this results in a 0-D array which can not # be indexed. y_values = np.ma.masked_all(2 * self.width) y_values[0::2] = minmax[:, 0] y_values[1::2] = minmax[:, 1] ax.plot(x_values, y_values, color=self.color) # Set the x-limit to avoid clipping of masked values. ax.set_xlim(0, self.width - 1) def __plotSetXTicks(self, *args, **kwargs): # @UnusedVariable """ Goes through all axes in pyplot and sets time ticks on the x axis. """ # Loop over all axes. for ax in self.axis: # Get the xlimits. start, end = ax.get_xlim() # Set the location of the ticks. ax.set_xticks(np.linspace(start, end, self.number_of_ticks)) # Figure out times. interval = float(self.endtime - self.starttime) / \ (self.number_of_ticks - 1) # Set the actual labels. if self.type == 'relative': s = ['%.2f' % (self.starttime + _i * interval).timestamp \ for _i in range(self.number_of_ticks)] else: labels = [(self.starttime + _i * \ interval).strftime(self.tick_format) for _i in \ range(self.number_of_ticks)] ax.set_xticklabels(labels, fontsize='small', rotation=self.tick_rotation) def __plotSetYTicks(self, *args, **kwargs): # @UnusedVariable """ Goes through all axes in pyplot, reads self.stats and sets all ticks on the y axis. This method also adjusts the y limits so that the mean value is always in the middle of the graph and all graphs are equally scaled. """ # Figure out the maximum distance from the mean value to either end. # Add 10 percent for better looking graphs. max_distance = max([max(trace[1] - trace[2], trace[3] - trace[1]) for trace in self.stats]) * 1.1 # Loop over all axes. for _i, ax in enumerate(self.axis): mean = self.stats[_i][1] # Set the ylimit. min_range = mean - max_distance max_range = mean + max_distance # Set the location of the ticks. ticks = [mean - 0.75 * max_distance, mean - 0.5 * max_distance, mean - 0.25 * max_distance, mean, mean + 0.25 * max_distance, mean + 0.5 * max_distance, mean + 0.75 * max_distance] ax.set_yticks(ticks) # Setup format of the major ticks if max(ticks) - min(ticks) > 10: fmt = '%d' else: fmt = '%.2g' ax.set_yticklabels([fmt % t for t in ax.get_yticks()], fontsize='small') # Set the title of each plot. ax.set_title(self.stats[_i][0], horizontalalignment='left', fontsize='small', verticalalignment='center') ax.set_ylim(min_range, max_range) def __dayplotGetMinMaxValues(self, *args, **kwargs): # @UnusedVariable """ Takes a Stream object and calculates the min and max values for each pixel in the dayplot. Writes a three dimensional array. The first axis is the step, i.e number of trace, the second is the pixel in that step and the third contains the minimum and maximum value of the pixel. """ # Helper variables for easier access. trace = self.stream[0] trace_length = len(trace.data) # Samples per interval. spi = int(self.interval * trace.stats.sampling_rate) # Check the approximate number of samples per pixel and raise # error as fit. spp = float(spi) / self.width if spp < 1.0: msg = """ Too few samples to use dayplot with the given arguments. Adjust your arguments or use a different plotting method. """ msg = " ".join(msg.strip().split()) raise ValueError(msg) # Number of intervals plotted. noi = float(trace_length) / spi inoi = int(round(noi)) # Plot an extra interval if at least 2 percent of the last interval # will actually contain data. Do it this way to lessen floating point # inaccuracies. if abs(noi - inoi) > 2E-2: noi = inoi + 1 else: noi = inoi # Adjust data. Fill with masked values in case it is necessary. number_of_samples = noi * spi delta = number_of_samples - trace_length if delta < 0: trace.data = trace.data[:number_of_samples] elif delta > 0: trace.data = np.ma.concatenate([trace.data, createEmptyDataChunk(delta, trace.data.dtype)]) # Create array for min/max values. Use masked arrays to handle gaps. extreme_values = np.ma.empty((noi, self.width, 2)) trace.data.shape = (noi, spi) ispp = int(spp) fspp = spp % 1.0 if fspp == 0.0: delta = None else: delta = spi - ispp * self.width # Loop over each interval to avoid larger errors towards the end. for _i in range(noi): if delta: cur_interval = trace.data[_i][:-delta] rest = trace.data[_i][-delta:] else: cur_interval = trace.data[_i] cur_interval.shape = (self.width, ispp) extreme_values[_i, :, 0] = cur_interval.min(axis=1) extreme_values[_i, :, 1] = cur_interval.max(axis=1) # Add the rest. if delta: extreme_values[_i, -1, 0] = min(extreme_values[_i, -1, 0], rest.min()) extreme_values[_i, -1, 1] = max(extreme_values[_i, -1, 0], rest.max()) # Set class variable. self.extreme_values = extreme_values def __dayplotNormalizeValues(self, *args, **kwargs): # @UnusedVariable """ Normalizes all values in the 3 dimensional array, so that the minimum value will be 0 and the maximum value will be 1. It will also convert all values to floats. """ # Convert to native floats. self.extreme_values = self.extreme_values.astype(np.float) * \ self.stream[0].stats.calib # Make sure that the mean value is at 0 self.extreme_values -= self.extreme_values.mean() # Scale so that 99.5 % of the data will fit the given range. if self.vertical_scaling_range is None: percentile_delta = 0.005 max_values = self.extreme_values[:, :, 1].compressed() min_values = self.extreme_values[:, :, 0].compressed() # Remove masked values. max_values.sort() min_values.sort() length = len(max_values) index = int((1.0 - percentile_delta) * length) max_val = max_values[index] index = int(percentile_delta * length) min_val = min_values[index] # Exact fit. elif float(self.vertical_scaling_range) == 0.0: max_val = self.extreme_values[:, :, 1].max() min_val = self.extreme_values[:, :, 0].min() # Fit with custom range. else: max_val = min_val = abs(self.vertical_scaling_range) / 2.0 # Scale from 0 to 1. self.extreme_values = self.extreme_values / (max(abs(max_val), abs(min_val)) * 2) self.extreme_values += 0.5 def __dayplotSetXTicks(self, *args, **kwargs): # @UnusedVariable """ Sets the xticks for the dayplot. """ max_value = self.width - 1 # Check whether it are sec/mins/hours and convert to a universal unit. if self.interval < 240: time_type = 'seconds' time_value = self.interval elif self.interval < 24000: time_type = '[min]' time_value = self.interval / 60 else: time_type = 'hours' time_value = self.interval / 3600 count = None # Hardcode some common values. The plus one is itentional. It had # hardly any performance impact and enhances readability. if self.interval == 15 * 60: count = 15 + 1 elif self.interval == 20 * 60: count = 4 + 1 elif self.interval == 30 * 60: count = 6 + 1 elif self.interval == 60 * 60: count = 4 + 1 elif self.interval == 90 * 60: count = 6 + 1 elif self.interval == 120 * 60: count = 4 + 1 elif self.interval == 180 * 60: count = 6 + 1 elif self.interval == 240 * 60: count = 6 + 1 elif self.interval == 300 * 60: count = 6 + 1 elif self.interval == 360 * 60: count = 12 + 1 elif self.interval == 720 * 60: count = 12 + 1 # Otherwise run some kind of autodetection routine. if not count: # Up to 15 time units and if its a full number, show every unit. if time_value <= 15 and time_value % 1 == 0: count = time_value # Otherwise determine whether they are dividable for numbers up to # 15. If a number is not dividable just show 10 units. else: count = 10 for _i in xrange(15, 1, -1): if time_value % _i == 0: count = _i break # Show at least 5 ticks. if count < 5: count = 5 # Everything can be overwritten by user specified number of ticks. if self.number_of_ticks: count = self.number_of_ticks # Calculate and set ticks. ticks = np.linspace(0.0, max_value, count) ticklabels = ['%i' % _i for _i in np.linspace(0.0, time_value, count)] self.axis[0].set_xticks(ticks) self.axis[0].set_xticklabels(ticklabels, rotation=self.tick_rotation) self.axis[0].set_xlabel('Zeit %s' % time_type) def __dayplotSetYTicks(self, *args, **kwargs): # @UnusedVariable """ Sets the yticks for the dayplot. """ intervals = self.extreme_values.shape[0] # Do not display all ticks except if it are five or less steps. if intervals <= 5: tick_steps = range(0, intervals) ticks = np.arange(intervals, 0, -1, dtype=np.float) ticks -= 0.5 else: tick_steps = range(0, intervals, self.repeat) ticks = np.arange(intervals, 0, -1 * self.repeat, dtype=np.float) ticks -= 0.5 ticklabels = [(self.starttime + (_i + 1) * self.interval + \ self.time_offset * 3600).strftime('%H:%M') \ for _i in tick_steps] self.axis[0].set_yticks(ticks) self.axis[0].set_yticklabels(ticklabels) # self.axis[0].set_ylabel('UTC') # Save range. yrange = self.axis[0].get_ylim() # Create twin axis. #XXX self.twin = self.axis[0].twinx() self.twin.set_ylim(yrange) self.twin.set_yticks(ticks) ticklabels = [(self.starttime + _i * self.interval).strftime('%H:%M') \ for _i in tick_steps] self.twin.set_yticklabels(ticklabels) # Complicated way to calculate the label of the y-Axis showing the # second time zone. sign = '%+i' % self.time_offset sign = sign[0] # time_label = self.timezone.strip() + ' (UTC%s%02i:%02i)' % \ time_label = 'Berlin' + ' (UTC%s%02i:%02i)' % \ (sign, abs(self.time_offset), (self.time_offset % 1 * 60)) self.axis[0].set_ylabel(time_label) self.twin.set_ylabel('UTC') def __setupFigure(self): """ The design and look of the whole plot to be produced. """ # Setup figure and axes self.fig = plt.figure(num=None, dpi=self.dpi, figsize=(float(self.width) / self.dpi, float(self.height) / self.dpi)) # XXX: Figure out why this is needed sometimes. # Set size and dpi. self.fig.set_dpi(self.dpi) self.fig.set_figwidth(float(self.width) / self.dpi) self.fig.set_figheight(float(self.height) / self.dpi) # hide time information if set as option if self.type == 'relative': return if self.type == 'dayplot': suptitle = '%s %s'%(self.stream[0].id,self.starttime.strftime('%Y-%m-%d')) self.fig.suptitle(suptitle, y=0.94, fontsize='small') else: pattern = '%Y-%m-%dT%H:%M:%SZ' suptitle = '%s - %s' % (self.starttime.strftime(pattern), self.endtime.strftime(pattern)) self.fig.suptitle(suptitle, x=0.02, y=0.96, fontsize='small', horizontalalignment='left')
from obspy.arclink import Client as C from obspy.core import UTCDateTime as dt from datetime import timedelta c = C(host='seisrequest.iag.usp.br', port=18001, user='******') d = dt.now() - timedelta(days = 1) print d-3600 s = c.getWaveform('BL', 'BB19B', '', "HH*", d - 3600, d) s.plot()
def __init__(self, **kwargs): """ Checks some variables and maps the kwargs to class variables. """ self.stream = kwargs.get('stream') # Check if it is a Stream or a Trace object. if isinstance(self.stream, Trace): self.stream = Stream([self.stream]) elif not isinstance(self.stream, Stream): msg = 'Plotting is only supported for Stream or Trace objects.' raise TypeError(msg) # Stream object should contain at least one Trace if len(self.stream) < 1: msg = "Empty object" raise IndexError(msg) # Type of the plot. self.type = kwargs.get('type', 'normal') # Start- and endtimes of the plots. self.starttime = kwargs.get('starttime', None) self.endtime = kwargs.get('endtime', None) self.fig_obj = kwargs.get('fig', None) # If no times are given take the min/max values from the stream object. if not self.starttime: self.starttime = min([trace.stats.starttime for \ trace in self.stream]) if not self.endtime: self.endtime = max([trace.stats.endtime for \ trace in self.stream]) # Map stream object and slice just in case. self.stream = self.stream.slice(self.starttime, self.endtime) # normalize times if self.type == 'relative': dt = self.starttime # fix plotting boundaries self.endtime = UTCDateTime(self.endtime - self.starttime) self.starttime = UTCDateTime(0) # fix stream times for tr in self.stream: tr.stats.starttime = UTCDateTime(tr.stats.starttime - dt) # Whether to use straight plotting or the fast minmax method. self.plotting_method = kwargs.get('method', 'fast') # Below that value the data points will be plotted normally. Above it # the data will be plotted using a different approach (details see # below). Can be overwritten by the above self.plotting_method kwarg. self.max_npts = 400000 # If automerge is enabled. Merge traces with the same id for the plot. self.automerge = kwargs.get('automerge', True) # Set default values. # The default value for the size is determined dynamically because # there might be more than one channel to plot. self.size = kwargs.get('size', None) # Values that will be used to calculate the size of the plot. self.default_width = 800 self.default_height_per_channel = 250 if not self.size: self.width = 800 # Check the kind of plot. if self.type == 'dayplot': self.height = 600 else: # One plot for each trace. if self.automerge: count = [] for tr in self.stream: if hasattr(tr.stats, 'preview') and tr.stats.preview: tr_id = tr.id + 'preview' else: tr_id = tr.id if not tr_id in count: count.append(tr_id) count = len(count) else: count = len(self.stream) self.height = count * 250 else: self.width, self.height = self.size # Interval length in minutes for dayplot. self.interval = 60 * kwargs.get('interval', 15) # Scaling. self.vertical_scaling_range = kwargs.get('vertical_scaling_range', None) # Dots per inch of the plot. Might be useful for printing plots. self.dpi = kwargs.get('dpi', 100) # Color of the graph. if self.type == 'dayplot': self.color = kwargs.get('color', ('#000000','#B2000F', '#004C12', '#0E01FF')) if isinstance(self.color, basestring): self.color = (self.color,) self.number_of_ticks = kwargs.get('number_of_ticks', None) else: self.color = kwargs.get('color', 'k') self.number_of_ticks = kwargs.get('number_of_ticks', 5) # Background and face color. self.background_color = kwargs.get('bgcolor', 'w') self.face_color = kwargs.get('face_color', 'w') # Transparency. Overwrites background and facecolor settings. self.transparent = kwargs.get('transparent', False) if self.transparent: self.background_color = None # Ticks. self.tick_format = kwargs.get('tick_format', '%H:%M:%S') self.tick_rotation = kwargs.get('tick_rotation', 0) # Whether or not to save a file. self.outfile = kwargs.get('outfile') self.handle = kwargs.get('handle') # File format of the resulting file. Usually defaults to PNG but might # be dependent on your matplotlib backend. self.format = kwargs.get('format')
def roundOrigin(self): # 1970-02-09T00:12:34.999990Z origin = UTCDateTime(self.date+'T'+self.time) origin = UTCDateTime(round(origin)) self.date = origin.strftime("%Y-%m-%d") self.time = origin.strftime("%H:%M:%S") self.o = origin
def test_formatSEED(self): """ Tests formatSEED method """ #1 dt = UTCDateTime("2010-01-01") self.assertEquals(dt.formatSEED(compact=True), "2010,001") #2 dt = UTCDateTime("2010-01-01T00:00:00.000000") self.assertEquals(dt.formatSEED(compact=True), "2010,001") #3 dt = UTCDateTime("2010-01-01T12:00:00") self.assertEquals(dt.formatSEED(compact=True), "2010,001,12") #4 dt = UTCDateTime("2010-01-01T12:34:00") self.assertEquals(dt.formatSEED(compact=True), "2010,001,12:34") #5 dt = UTCDateTime("2010-01-01T12:34:56") self.assertEquals(dt.formatSEED(compact=True), "2010,001,12:34:56") #6 dt = UTCDateTime("2010-01-01T12:34:56.123456") self.assertEquals(dt.formatSEED(compact=True), "2010,001,12:34:56.1234") #7 - explicit disabling compact flag still results into compact date if # no time information is given dt = UTCDateTime("2010-01-01") self.assertEquals(dt.formatSEED(compact=False), "2010,001")
def read_input_command(parser): """ Create input object (dictionary) based on command-line options. The default values are as "input" object (below) """ global input input = { 'address': 'psdata', 'min_date': UTCDateTime.utcnow() - 60 * 60 * 24 * 10 * 1, 'max_date': UTCDateTime.utcnow(), 'min_mag': 3.0, 'max_mag': 9.9, 'min_depth': +10.0, 'max_depth': -6000.0, 'evlatmin': -90.0, 'evlatmax': +90.0, 'evlonmin': -180.0, 'evlonmax': +180.0, 'identity': '*.*.*.*', 'file': 'Pdiff', 'model': 'iasp91', 'phase': 'Pdiff', 'freq': None, } # feed input dictionary of defaults into parser object parser.set_defaults(**input) # parse command line options (options, args) = parser.parse_args() # command line options can now be accessed via options.varname. # parse address (check if given absolute or relative) if options.address: if not os.path.isabs(options.address): options.address = os.path.join(os.getcwd(), options.address) # extract min. and max. longitude and latitude if the user has given the # coordinates with -r (GMT syntax) if options.event_rect: try: options.event_rect = options.event_rect.split('/') if len(options.event_rect) != 4: print "Erroneous rectangle given." sys.exit(2) options.evlatmin = float(options.event_rect[0]) options.evlonmin = float(options.event_rect[1]) options.evlatmax = float(options.event_rect[2]) options.evlonmax = float(options.event_rect[3]) except: print "Erroneous rectangle given." sys.exit(2) input['address'] = options.address input['min_date'] = UTCDateTime(options.min_date) input['max_date'] = UTCDateTime(options.max_date) input['min_mag'] = float(options.min_mag) input['max_mag'] = float(options.max_mag) input['min_depth'] = float(options.min_depth) input['max_depth'] = float(options.max_depth) if options.event_rect: input['evlonmin'] = options.evlonmin input['evlonmax'] = options.evlonmax input['evlatmin'] = options.evlatmin input['evlatmax'] = options.evlatmax input['all_sta'] = options.all_sta input['identity'] = options.identity input['file'] = options.file input['model'] = options.model input['phase'] = options.phase.split('-') input['freq'] = options.freq if input['freq'] != None: input['freq'] = float(options.freq)
#Lets set the search for the following magnitude scale searchParameter = '&minmagnitude=' + str(parserval.minMag) + \ '&maxmagnitude=' + str(parserval.maxMag) + \ '&mindepth=' + str(parserval.minDep) + \ '&eventtype=earthquake' #Lets setup the time for the search if parserval.time: try: if debug: print 'Here is the time in: ' + \ parserval.time.split(',')[0] stime = UTCDateTime(parserval.time.split(',')[0] + "-" + \ parserval.time.split(',')[1] + "T00:00:00.0") except: print 'Problem reading epoch' sys.exit(0) if debug: print 'Here is the epoch time of interest:' + str(stime) etime = stime + parserval.number*24*60*60 #Lets format for the USGS webservices stimeString = 'starttime=' + (stime.format_iris_web_service()).replace('T','%20') etimeString = 'endtime=' + (etime.format_iris_web_service()).replace('T','%20') if debug: print 'Start time string: ' + stimeString
def originfmt(self): o = UTCDateTime(self.date+"T"+self.time) o = UTCDateTime(round(o,3)) self.date = o.strftime("%Y-%m-%d") self.time = o.strftime("%H:%M:%S.%f")[0:12]
#!/usr/bin/env python import commands import glob import multical from obspy.core import UTCDateTime today = UTCDateTime.now() jday = today.julday yearCur = today.year logFilepath = '/home/ambaker/calanalyzer/logs/' + today.strftime('%Y%j %H%M') + '.log' #get first year years = [] paths = glob.glob('/xs[01]/seed/*/*') for path in paths: if path.split('/')[-1] not in years: if path.split('/')[-1].isdigit(): years.append(path.split('/')[-1]) years.sort() yearFirst = years[0] def printOutput(output): output = output[1].split('\n') fob = open(logFilepath, 'a') for line in output: if 'cal found' in line: fob.write(line + '\n') fob.write(str(UTCDateTime.now())) fob.close()
__author__ = 'bruno' from obspy.core import read, UTCDateTime from os import walk, sep, remove, path, makedirs from shutil import move import smtplib import logging now = str(UTCDateTime.now())[:19].replace(':','-') ## Filling vars sds = "/SDS" sdsNRT = "/SDS-NRT" logFile = '/home/suporte/nrtSync_logs/nrtSync.'+now+'.log' logging.basicConfig(filename=logFile,level=logging.DEBUG) nJoinedFiles = 0 nMovedFiles = 0 jdays = [] ## Control Vars noErrors = True for root, dirs, files in walk(sdsNRT): ## walking NRT path for nrtFile in files: try: st = read(root+sep+nrtFile) ## read a NRT file and get info from header
#handle = plt.axes(projection=ccrs.AlbersEqualArea(central_lon, central_lat)) handle.set_extent(extent) handle.add_feature(cfeature.LAND) handle.add_feature(cfeature.OCEAN) handle.add_feature(cfeature.COASTLINE) #handle.add_feature(cfeature.BORDERS, linestyle=':') handle.add_feature(cfeature.LAKES) handle.add_feature(cfeature.RIVERS) #handle.add_feature(cfeature.STATES, edgecolor='gray') return handle net = 'NE,IW' stime = UTCDateTime('2009-204T00:00:00') etime = UTCDateTime('2019-204T00:00:00') fig = plt.figure(figsize=(12, 6)) inv = client.get_stations(network=net, station="*", channel='*HZ', level="response", starttime=stime, endtime=etime) lats, lons, cols = [], [], [] for cnet in inv: for sta in cnet: for chan in sta:
from obspy.core import UTCDateTime t_now = UTCDateTime() t_bd = UTCDateTime(2011, 7, 9) days = t_bd.julday - t_now.julday print days, "days to my birthday" bday = t_bd.isoweekday() print "my birthday is day of week no.", bday # we could also map this to a string representation using a dictionary weekdays = {1: "monday", 2: "tuesday", 3: "wednesday", 4: "thursday", 5: "friday", 6: "saturday", 7: "sunday"} bday = weekdays[bday] print "my birthday is a", bday party = t_bd + (24 * 60 * 60) while party.isoweekday() != 6: party += (24 * 60 * 60) print "the party is going to be on", party.date
# Required Python and Obspy modules will be imported in this part. import matplotlib.pyplot as plt import os from obspy.core import UTCDateTime, read try: from obspy.signal import seisSim except Exception, e: from obspy.signal.invsim import seisSim from obspyDMT.utils.event_handler import get_Events from obspyDMT.utils.fdsn_handler import FDSN_network from obspyDMT.utils.input_handler import command_parse, read_input_command from obspyDMT.utils.instrument_handler import FDSN_ARC_IC from obspyDMT.utils.update_handler import FDSN_update dir_name = int(UTCDateTime.now().timestamp) # ##################### test_FDSN_network ################################## def test_FDSN_network(): (options, args, parser) = command_parse() input_dics = read_input_command(parser) # Changing the input_dics values for testing input_dics['min_date'] = '2011-03-01' input_dics['max_date'] = '2011-03-20' input_dics['min_mag'] = 8.9 input_dics['datapath'] = 'test_%s' % dir_name input_dics['net'] = 'TA' input_dics['sta'] = 'Z3*' input_dics['cha'] = 'BHZ'
def fetch(datemin=UTCDateTime(2011, 1, 1), datemax=UTCDateTime(), latmin=-90, latmax=90, lonmin=-180, lonmax=180, magmin=0, nmax=999999, datadir='mt-geofon'): """ Downloads all moment tensor solutions from GEOFON Global Seismic Monitor. :param datemin: string, optional Start date - MT catalog starts 01/2011 - so dates before will be truncated to 2011-01-01, defaults to '2011-01-01'. :param datemax: string, optional End date, defaults to today. :param latmin: float, optional Latitude minimum, defaults to -90. :param latmax: float, optional Latitude maximum, defaults to 90. :param lonmin: float, optional Longitude minimum, defaults to -180. :param lonmax: float, optional Longitude maximum, defaults to 180. :param magmin: float, optional Magnitude minimum, defaults to 0. :param nmax: int, optional Max entries, defaults to 999999. :param datadir: string, optional Directory where moment tensors are saved into, defaults to 'mt-geofon'. """ # process input parameters datemin = UTCDateTime(datemin) if datemin < UTCDateTime(2011, 1, 1): datemin = UTCDateTime(2011, 1, 1) datemin = datemin.date datemax = UTCDateTime(datemax).date params = urllib.urlencode({ 'fmt': 'html', 'datemin': datemin, 'datemax': datemax, 'latmin': latmin, 'latmax': latmax, 'lonmin': lonmin, 'lonmax': lonmax, 'magmin': magmin, 'nmax': nmax }) # fetch catalog data = urllib.urlopen(CATALOG_URL % params).read() # filter for moment tensors urls = re.findall(PATTERN, data) print "Found %d moment tensors" % len(urls) # save moment tensor files into given directory if not os.path.exists(datadir): os.mkdir(datadir) for url in urls: print "Fetching %s ..." % url data = urllib.urlopen(url).read() dt = data.splitlines()[1].replace(' ', '_').replace('/', '-') filename = os.path.join(datadir, '20' + dt + '.txt') fh = open(filename, 'wt') fh.write(data) fh.close()
def yearScale(self, top=True): """ Creates the subdivisions of the year scale. """ color = self.color1 # Shortcut to window geometry. starttime = self.env.starttime endtime = self.env.endtime time_range = float(endtime - starttime) # Pixel counts. start_x = 0 end_x = self.width - start_x x_range = end_x - start_x start_y = 0 end_y = self.subscale_height y_range = self.subscale_height # Get the number of years. year_count = endtime.year - starttime.year years = range(starttime.year, endtime.year + 1) # Loop over all years. for _i, year in enumerate(years): # Some variables. start_of_year = UTCDateTime(year, 1, 1) end_of_year = UTCDateTime(year + 1, 1, 1) # Calculate boundaries. start_frac = (start_of_year - starttime) / time_range if start_frac < 0: start_frac = 0 start = start_frac * x_range if start < 0: start = 0 start += start_x end_frac = (endtime - end_of_year) / time_range end_frac = 1.0 - end_frac if end_frac > 1.0: end_frac = 1.0 end = end_frac * x_range end = x_range - end if end > x_range: end = x_range end += start_x graph_width = (end_frac - start_frac) * x_range # Only draw every second box. if _i % 2: year_box = QtGui.QGraphicsRectItem(start, start_y, graph_width, y_range) year_box.start_frac = start_frac year_box.end_frac = end_frac year_box.setBrush(color) year_box.setZValue(-198) self.addToGroup(year_box) # Add to list for easier tracking. self.year_boxes.append(year_box) # If two narrow do not add a name. if graph_width < 30: continue # Add name. year_name = QtGui.QGraphicsSimpleTextItem(str(year)) rect = year_name.boundingRect() # XXX: The +2 at the end is just trial end error. I cannot figure # out a way to calculate it. The height of the rectangle is 16 # while the year subscale height is only 15. But the text is still # positioned too high without the +2. year_name.moveBy(((end_frac - start_frac) / 2 + start_frac) * self.width - \ rect.width() / 2, start_y + 2) year_name.start_frac = start_frac year_name.end_frac = end_frac self.year_labels.append(year_name) self.addToGroup(year_name)
from obspy.signal.spectral_estimation import get_nlnm, get_nhnm from obspy.clients.fdsn import Client from obspy.core import UTCDateTime, Stream import matplotlib.pyplot as plt import numpy as np import matplotlib as mpl from scipy import signal import sys mpl.rc('font', family='serif') mpl.rc('font', serif='Times') mpl.rc('text', usetex=True) mpl.rc('font', size=18) #client = Client("http://vmdevwb.cr.usgs.gov/metadatairis" , timeout=20) client = Client() stime = UTCDateTime('2019-191T20:07:00') etime = UTCDateTime('2019-191T20:17:00') #stime = UTCDateTime('2019-193T20:07:00') #etime = UTCDateTime('2019-193T20:27:00') st = client.get_waveforms("GS", "CA01", "00", "LH*", stime, etime, attach_response=True) #st.normalize() st.detrend('constant') #st.detrend('linear') #st.filter('lowpass', freq=1./20.)
tr.stats.distance = dist tr.stats.eve_coord = eve_coordinate tr.stats.eve_ot = eve_ot tr.stats["coordinates"] = {} tr.stats["coordinates"]["latitude"] = sta_coordinate[0] tr.stats["coordinates"]["longitude"] = sta_coordinate[1] return tr e = np.array([9, -25.9665, 131.9755, 1.1, 2013, 6, 9, 14, 22, 12, 5.8, 5.43]) data_dir = './output/' eve_id = 'eve_' + str(int(e[0])) station_file = data_dir + 'stations_eve_' + str(int(e[0])) + '.txt' waveform_file = data_dir + 'waveforms_eve_' + str(int(e[0])) + '.pkl' eve_coordinate = (float(e[1]), float(e[2])) eve_ot = UTCDateTime(int(e[4]), int(e[5]), int(e[6]), int(e[7]), int(e[8]), float(e[9])) st = read(waveform_file) st_all = Stream() freq4 = [0.01, 0.03, 15, 20.] ratio1 = 20. ratio2 = 8.0 line = 'WC4 -19.9619 134.3397 6.38647400151 0 0 1 0 0 1' sta = line.split(' ') sta_code = sta[0] sta_coordinate = (float(sta[1]), float(sta[2])) tr_bhn = create_trace(st, sta_code, sta_coordinate, 'BHN', eve_coordinate, eve_ot, freq4, ratio1, ratio2) tr_bhe = create_trace(st, sta_code, sta_coordinate, 'BHE', eve_coordinate, eve_ot, freq4, ratio1, ratio2)
sp = i_Sarr - i_Parr i_start = i_Parr - timedelta(seconds=td) i_end = i_Sarr + timedelta(seconds=90) i_network = str(i_network) i_station = str(i_station) ########################################################################################################################################3 # chlear stream objects raw_stn = Stream() raw_ste = Stream() #data download and plot for Nort try: raw_stn += client.get_waveforms(i_network, i_station, "*", 'HHN', UTCDateTime(i_start), UTCDateTime(i_end), attach_response=True) except: nummissed += .5 print('oops') continue i_stn = raw_stn.copy() j_stn = raw_stn.copy() samprate = i_stn[0].stats['sampling_rate'] ## Make the prefilt for the instrment response - AT.SIT is @ 50Hz so 25 is nyquist prefilt1 = (0.005, 0.006, ((samprate / 2) - 5), (samprate / 2) ) ## this is 20 to 25 at the end i_stn[0].remove_response( output='VEL',
def wavesdownloader(args): ################################################################# # ---- Check if internet connection is active # # check servers args.server=list2servers(args.server,'N') # Do not apply if only LOCAL is active if (args.server[0] == 1 or args.server[1] == 1 or args.server[3] == 1 or args.server[4] == 1): try: urllib2.urlopen("http://google.com", timeout=2) except urllib2.URLError: print "No internet connection" sys.exit() ################################################################# # ---- C. Initialize variables ---- # dataStreamEida = Stream() dataStreamIris = Stream() dataStreamLoca = Stream() dataStreamWbDc = Stream() dataStream = Stream() center=args.center.split(' ') grradius=args.radius.split(' ') kmradius=args.radius.split(' ') ev_lat=eval(center[0]) ev_lon=eval(center[1]) kmradius[0]=eval(kmradius[0])*100 kmradius[1]=eval(kmradius[1])*100 bbox=getBBox(args.supCor,args.infCor) #minlat minlon maxlat maxlon aFormat="fseed" aFORMAT="FSEED" irisClient = IClient() ID = "0" # check consistency of arguments checkConsistency(args) # define t1 and t2 if args.end=="None": t1 = UTCDateTime(args.beg) t1.getTimeStamp() t2 = t1+int(args.len) t2= str(t2)[:19] #this must be a string for args.end=t2 else: t1 = UTCDateTime(args.beg) t2 = UTCDateTime(args.end) if t1 >= t2: print "Wrong begin and end time entries" sys.exit() # make outdir if not exist (from myUsefullFuncs) if args.outdir != ".": mkdir(args.outdir) # if filtering require data writing if args.wfiltr == "Y": mkdir(args.outdir + os.sep + "_f") # write summary makeSummary(1,dataStream,args) # check for local fseed archive if args.server[2] == 1 and args.fsfile == "None": print "local fseed file non spcified. Check --fsfile option" sys.exit(0) ################################################################# # ---- D. Download waveforms (fseed and stream) # if eida is on if args.server[0] == 1: # Convert some args for eida syntax args.net=reformatNetStaList(args.net,"eida") args.sta=reformatNetStaList(args.sta,"eida") args.cha=reformatChaStaList(args.cha,"eida") # initialize eida requestor user=INGV_requestor(args.usr,args.pas) # download print "\n \nDownloading from eida" if args.mode == "circular": (downloadPath,ID) = user.run_circular_query( \ args.net,args.sta,args.cha, \ center[0],center[1],kmradius[0],kmradius[1], \ args.beg,args.end,aFORMAT) else: # i.e.: rectangular (downloadPath,ID) = user.run_rectangular_query( \ args.net,args.sta,args.cha, \ bbox[0],bbox[1],bbox[2],bbox[3], \ args.beg,args.end,aFORMAT) #set name and location of the fseed archiveFile = downloadPath + os.sep + ID + "_data.tgz" (root,seed)=grabIngvEidaArchive(archiveFile,aFormat) # get stream try: dataStreamEida = read(seed) except: print "no data found or no response from Eida server" # if iris is on if args.server[1] == 1: # Convert some args for eida syntax args.net=reformatNetStaList(args.net,"iris") args.sta=reformatNetStaList(args.sta,"iris") args.cha=reformatNetStaList(args.cha,"iris") # initialize downloader print "\n \nDownloading from iris" if args.mode == "circular": response = irisClient.availability( \ network=args.net, station=args.sta, channel=args.cha, \ location=args.loc,starttime=t1, endtime=t2, \ lat=center[0], lon=center[1], minradius=grradius[0], maxradius=grradius[1]) else: # i.e.: rectangular IrisBox = setIrisRectBox(bbox) response = irisClient.availability( \ network=args.net, station=args.sta, channel=args.cha, \ location=args.loc,starttime=t1, endtime=t2,\ minlat=IrisBox[0], minlon=IrisBox[1], maxlat=IrisBox[2], maxlon=IrisBox[3]) # Download try: dataStreamIris = irisClient.bulkdataselect(response) # here save mseed file format dataStreamIris.write(args.outdir + os.sep + 'iris.' + ID + '_data.mseed',format='MSEED', encoding='STEIM2') except: print "IRIS bulkdataselect returns False. No data from IRIS\n\n" # # if local is on if args.server[2] == 1: print "\n \nExtracting from local fseed" dataStreamLoca=read(args.fsfile) # if ARClink - WEBDC is on if args.server[3] == 1: print "\n \nDownloading from WEBDC via ArcLink" # Convert some args for eida syntax args.net=reformatNetStaList(args.net,"iris") args.sta=reformatNetStaList(args.sta,"iris") args.cha=reformatNetStaList(args.cha,"iris") # get station list available Inventory=getInventoryViaArcLink(t1,t2,center,grradius,bbox,args) # download data dataStreamWbDc=getDataViaArcLink(t1,t2,Inventory,args) if len(dataStreamWbDc) > 0: dataStreamWbDc.write(args.outdir + os.sep + 'webdc.' + ID + '_data.mseed',format='MSEED', encoding='STEIM2') ############################################################ # Check if only empty data if(len(dataStreamIris) + len(dataStreamEida) + len(dataStreamLoca) + len(dataStreamWbDc)<=0): print "\nNo data found! Exit!" sys.exit() ############################################################ # ---- E. data to sac (or other formats) # trim data if args.beg!="None" or args.end!="None": Tb = UTCDateTime(args.beg) Te = UTCDateTime(args.end) dataStreamIris.trim(starttime=Tb, endtime=Te) dataStreamEida.trim(starttime=Tb, endtime=Te) dataStreamLoca.trim(starttime=Tb, endtime=Te) dataStreamWbDc.trim(starttime=Tb, endtime=Te) # find gaps and remove those traces if args.rmgaps=="Y": dataStreamIris = removeGaps(dataStreamIris, args.mingap, args.maxgap, verbose="true") dataStreamEida = removeGaps(dataStreamEida, args.mingap, args.maxgap, verbose="true") dataStreamLoca = removeGaps(dataStreamLoca, args.mingap, args.maxgap, verbose="true") dataStreamWbDc = removeGaps(dataStreamWbDc, args.mingap, args.maxgap, verbose="true") # Remove traces shorter than expected tolerance args.reject=eval(args.reject) if args.reject <= 100: dataStreamIris=removeShortTraces(dataStreamIris,args.reject,Tb,Te) dataStreamEida=removeShortTraces(dataStreamEida,args.reject,Tb,Te) dataStreamLoca=removeShortTraces(dataStreamLoca,args.reject,Tb,Te) dataStreamWbDc=removeShortTraces(dataStreamWbDc,args.reject,Tb,Te) # Remove mean and trend if required if args.demean == "Y": dataStreamIris=removeMeanTrend(dataStreamIris) dataStreamEida=removeMeanTrend(dataStreamEida) dataStreamLoca=removeMeanTrend(dataStreamLoca) dataStreamWbDc=removeMeanTrend(dataStreamWbDc) # Decimation if required if args.deci != "None": dataStreamIris=decimateStream(dataStreamIris,args.deci) dataStreamEida=decimateStream(dataStreamEida,args.deci) dataStreamLoca=decimateStream(dataStreamLoca,args.deci) dataStreamWbDc=decimateStream(dataStreamWbDc,args.deci) ############################################################ # ---- F. metadata, response, and paz files and update header # for arcklink data Paz already exists. Resp file can't # be downloaded now (12.10.2012) # eida - very easy if args.server[0] == 1: #if args.res != "0": # and args.reqFileFormat != "MSEED": # first test if fseed file exists aa = os.path.isfile(seed) if aa == "False": print "No data found in fseed file from EIDA" else: (respFiles, pazFiles) = extractResponse(seed,args.res,args.outdir) if args.res == "2" or args.res == "3": dataStreamEida = addPazStats(dataStreamEida,args.outdir,pazFiles) dataStreamEida = updateStats(dataStreamEida,args.outdir,"rdseed.stations",ev_lat,ev_lon) try: shutil.move(seed,args.outdir + os.sep + 'eida.' + ID + '_data.fseed') except: pass try: shutil.move(args.outdir + os.sep + 'rdseed.stations',args.outdir + os.sep + 'eida_rdseed.stations') except: pass # local same than eida - very easy if args.server[2] == 1: #if args.res != "0": (respFiles, pazFiles) = extractResponse(args.fsfile,args.res,args.outdir) if args.res == "2" or args.res == "3": dataStreamLoca = addPazStats(dataStreamLoca,args.outdir,pazFiles) dataStreamLoca = updateStats(dataStreamLoca,args.outdir,"rdseed.stations",ev_lat,ev_lon) dataStreamLoca = purgeListStation(dataStreamLoca,args,'d') shutil.move(args.outdir + os.sep + 'rdseed.stations',args.outdir + os.sep + 'local_rdseed.stations') # iris - longer if args.server[1] == 1: pazFiles = [] temp_iris = open(args.outdir + os.sep + "tmp_iris.station","w") # here store lat lon staz locId for later update of iris stream for i in range(len(dataStreamIris)): n = dataStreamIris[i].stats['network'] s = dataStreamIris[i].stats['station'] l = dataStreamIris[i].stats['location'] c = dataStreamIris[i].stats['channel'] nameresp = "RESP." + n + "." + s + "." + l + "." + c namepaz = "SAC.PZs." + n + "." + s + "." + c # get metadata station latitude and longitude meta = irisClient.station(network=n, station=s, location=l, channel=c, starttime=t1, endtime=t2) (lat,lon) = getXmlTagData(meta) # update temp_iris temp_iris.write(s + " " + n + " " + lat + " " + lon + "0.0\n") # write resp files if args.res == "1" or args.res == "3": irisClient.saveResponse(filename=args.outdir + os.sep + nameresp ,network=n, station=s, location=args.loc, channel=c,\ starttime=t1, endtime=t2, format='RESP') if args.res == "2" or args.res == "3": sacpz = irisClient.sacpz(network=n, station=s, location=args.loc, channel=c, starttime=t1, endtime=t2) sacpz = sac4sac(sacpz) f = open(args.outdir + os.sep + namepaz, 'w') f.write(sacpz) f.close() # close close close!!!! porcoIddio che mi dimentico sempre!!! pazFiles.append(namepaz) # lose temp_iris temp_iris.close() # update stream dataStreamIris = updateStats(dataStreamIris,args.outdir,"tmp_iris.station",ev_lat,ev_lon) if args.res == '2' or args.res == '3': dataStreamIris = addPazStats(dataStreamIris,args.outdir,pazFiles) if args.server[3] == 1: # Write webdc.stations file and extract PZ file # and update lat lon and event loc into statz for consistency dataStreamWbDc=writeWbDcStation(dataStreamWbDc,args) if args.res == "2" or args.res == "3": PzFileFromStat(dataStreamWbDc,args) print "\nWarning, RESP files can not be downloaded from WebDC vie ArcLink\n" if args.res == "1": print "\nWarning, RESP files can not be downloaded from WebDC vie ArcLink\n" ############################################################# ## ---- G. Join all traces and write mseed files with original data for i in range(len(dataStreamEida)): dataStream.append(dataStreamEida[i]) for i in range(len(dataStreamIris)): dataStream.append(dataStreamIris[i]) for i in range(len(dataStreamLoca)): dataStream.append(dataStreamLoca[i]) for i in range(len(dataStreamWbDc)): dataStream.append(dataStreamWbDc[i]) # Stop and exit id no data downloaded if len(dataStream) == 0: print "\n\nNo data available!\n" sys.exit() ############################################################# ## ---- join stations files files = [] if (args.server[0] == 1): if(args.outdir + os.sep + "tmp_iris.station" == True): files.append(args.outdir + os.sep + "tmp_iris.station") if (args.server[1] == 1): if(args.outdir + os.sep + "eida_rdseed.stations" == True): files.append(args.outdir + os.sep + "eida_rdseed.stations") content = '' for f in files: content = content + '\n' + open(f).read() open(args.outdir + os.sep + 'list.stations','w').write(content) ############################################################# ## ---- H. Make deconvolution of instrument if args.deco == "Y": dataStream = removeInstrument(dataStream,args) ############################################################# ## ---- I. Rotate orizontal to GCP if args.rot == "Y": rotatDataStream = rotateToGCP(dataStream) # join horizontal with rotated dataStream=join_NERT(dataStream,rotatDataStream) ############################################################# # Write fseed to sac if(args.format!="None"): RsacFilesEida = fromFseed2sac(dataStream, args.format, args.outdir, args.format) for i in range(len(RsacFilesEida)): lat=dataStream[i].stats['stla'] lon=dataStream[i].stats['stlo'] ev_lat=dataStream[i].stats['evla'] ev_lon=dataStream[i].stats['evlo'] ok = updateSacHeader(RsacFilesEida[i],args.outdir,lat,lon,ev_lat,ev_lon) ############################################################# ## ---- L. Write mseed to store semi-processed data. # ---- and other output files # if needs to repeat analysis with different parameters on these data just add option # --redo "Y" to your data request line. --server and --res will be automatically disabled # and the following mseed file will be loaded. Do not change the name of this file if you want to use # --redo "Y" # analysis includes only --filter --cFreq --Sta/Lta --deco #dataStream.write(args.outdir + os.sep + 'downloadedData.mseed', format='MSEED',encoding='FLOAT64') # and make summary level 2 (write stats.elements not writable on mseed makeSummary(2,dataStream,args) ############################################################ # ---- Write output files # kml file station for google createKML(dataStream,args.outdir) ############################################################ # ---- START DATA ANALYSIS: ############################################################ # ---- M: filter data if required (deafult=none) if args.bandpass == "0" and args.lowpass == "0" and args.highpass == "0": pass else: dataStream=FilterData(dataStream, args.bandpass, args.highpass, args.lowpass) ############################################################# ## ---- N. Write processed data with filter . This include also rotated filtered data if args.wfiltr != "N": outP = args.outdir + os.sep + args.wfiltr mkdir(outP) FsacFiles = fromFseed2sac(dataStream, args.format, outP, args.format) ############################################################# ## ---- O. compute central frequency, Sta/Lta # Initialize stats for this section dataStream=initStats(dataStream) # central frequency """ The period is determined as the period of the maximum value of the Fourier amplitude spectrum. """ if args.cfreq=="Y": dataStream=cFreqStream(dataStream) # pick using sta/lta staLtaStream=Stream() if args.slta!="None": staLtaStream=StaLta(dataStream,args.slta) staLtaStream=trig(staLtaStream,args.slta) staLtaStream.write(args.outdir + os.sep + 'picks.mseed', format='MSEED',encoding='FLOAT64') dataStream=syncStat(staLtaStream,dataStream) # if required to write if args.wcf == "Y": SL = fromFseed2sac(staLtaStream,"SAC",args.outdir,'slt') # get PGMs: if args.pgm=="Y": dataStream=get_PGMs(dataStream,args) if(args.shake == 'Y'): (xmlHeader,shakeLines)=export4ShakeMap(dataStream) writeShake(xmlHeader,shakeLines,args) # write summary level 3: data analysis makeSummary(3,dataStream,args) ############################################################ # ---- P. Plot args.pltmode = int(args.pltmode) if args.pltmode!=0: plotWaves(dataStream,args.pltmode, \ kmradius, args.mode,args.pltchan, \ args.pltNERT,args.pltazi, \ staLtaStream,args.slta, args.outdir, args.rot)
def main(): print() print("#########################################") print("# __ _ _ #") print("# _ __ / _|_ __ _ _ | |__ | | __ #") print("# | '__| |_| '_ \| | | | | '_ \| |/ / #") print("# | | | _| |_) | |_| | | | | | < #") print("# |_| |_| | .__/ \__, |___|_| |_|_|\_\ #") print("# |_| |___/_____| #") print("# #") print("#########################################") print() # Run Input Parser args = arguments.get_hk_arguments() # Load Database db = stdb.io.load_db(fname=args.indb) # Construct station key loop allkeys = db.keys() sorted(allkeys) # Extract key subset if len(args.stkeys) > 0: stkeys = [] for skey in args.stkeys: stkeys.extend([s for s in allkeys if skey in s]) else: stkeys = db.keys() sorted(stkeys) # Loop over station keys for stkey in list(stkeys): # Extract station information from dictionary sta = db[stkey] # Define path to see if it exists if args.phase in ['P', 'PP', 'allP']: datapath = Path('P_DATA') / stkey elif args.phase in ['S', 'SKS', 'allS']: datapath = Path('S_DATA') / stkey if not datapath.is_dir(): print('Path to ' + str(datapath) + ' doesn`t exist - continuing') continue # Define save path if args.save: savepath = Path('HK_DATA') / stkey if not savepath.is_dir(): print('Path to ' + str(savepath) + ' doesn`t exist - creating it') savepath.mkdir(parents=True) # Get search start time if args.startT is None: tstart = sta.startdate else: tstart = args.startT # Get search end time if args.endT is None: tend = sta.enddate else: tend = args.endT if tstart > sta.enddate or tend < sta.startdate: continue # Temporary print locations tlocs = sta.location if len(tlocs) == 0: tlocs = [''] for il in range(0, len(tlocs)): if len(tlocs[il]) == 0: tlocs[il] = "--" sta.location = tlocs # Update Display print(" ") print(" ") print("|===============================================|") print("|===============================================|") print("| {0:>8s} |".format( sta.station)) print("|===============================================|") print("|===============================================|") print("| Station: {0:>2s}.{1:5s} |".format( sta.network, sta.station)) print("| Channel: {0:2s}; Locations: {1:15s} |".format( sta.channel, ",".join(tlocs))) print("| Lon: {0:7.2f}; Lat: {1:6.2f} |".format( sta.longitude, sta.latitude)) print("| Start time: {0:19s} |".format( sta.startdate.strftime("%Y-%m-%d %H:%M:%S"))) print("| End time: {0:19s} |".format( sta.enddate.strftime("%Y-%m-%d %H:%M:%S"))) print("|-----------------------------------------------|") rfRstream = Stream() datafiles = [x for x in datapath.iterdir() if x.is_dir()] for folder in datafiles: # Skip hidden folders if folder.name.startswith('.'): continue date = folder.name.split('_')[0] year = date[0:4] month = date[4:6] day = date[6:8] dateUTC = UTCDateTime(year + '-' + month + '-' + day) if dateUTC > tstart and dateUTC < tend: # Load meta data metafile = folder / "Meta_Data.pkl" if not metafile.is_file(): continue meta = pickle.load(open(metafile, 'rb')) # Skip data not in list of phases if meta.phase not in args.listphase: continue # QC Thresholding if meta.snrh < args.snrh: continue if meta.snr < args.snr: continue if meta.cc < args.cc: continue # # Check bounds on data # if meta.slow < args.slowbound[0] and meta.slow > args.slowbound[1]: # continue # if meta.baz < args.bazbound[0] and meta.baz > args.bazbound[1]: # continue # If everything passed, load the RF data filename = folder / "RF_Data.pkl" if filename.is_file(): file = open(filename, "rb") rfdata = pickle.load(file) rfRstream.append(rfdata[1]) file.close() if rfdata[0].stats.npts != 1451: print(folder) if len(rfRstream) == 0: continue if args.no_outl: t1 = 0. t2 = 30. varR = [] for i in range(len(rfRstream)): taxis = rfRstream[i].stats.taxis tselect = (taxis > t1) & (taxis < t2) varR.append(np.var(rfRstream[i].data[tselect])) varR = np.array(varR) # Remove outliers wrt variance within time range medvarR = np.median(varR) madvarR = 1.4826 * np.median(np.abs(varR - medvarR)) robustR = np.abs((varR - medvarR) / madvarR) outliersR = np.arange(len(rfRstream))[robustR > 2.5] for i in outliersR[::-1]: rfRstream.remove(rfRstream[i]) print('') print("Number of radial RF data: " + str(len(rfRstream))) print('') # Try binning if specified if args.calc_dip: rf_tmp = binning.bin_baz_slow(rfRstream, nbaz=args.nbaz + 1, nslow=args.nslow + 1, pws=args.pws) rfRstream = rf_tmp[0] else: rf_tmp = binning.bin(rfRstream, typ='slow', nbin=args.nslow + 1, pws=args.pws) rfRstream = rf_tmp[0] # Get a copy of the radial component and filter if args.copy: rfRstream_copy = rfRstream.copy() rfRstream_copy.filter('bandpass', freqmin=args.bp_copy[0], freqmax=args.bp_copy[1], corners=2, zerophase=True) # Check bin counts: for tr in rfRstream: if (tr.stats.nbin < args.binlim): rfRstream.remove(tr) # Continue if stream is too short if len(rfRstream) < 5: continue if args.save_plot and not Path('HK_PLOTS').is_dir(): Path('HK_PLOTS').mkdir(parents=True) print('') print("Number of radial RF bins: " + str(len(rfRstream))) print('') # Filter original stream rfRstream.filter('bandpass', freqmin=args.bp[0], freqmax=args.bp[1], corners=2, zerophase=True) # Initialize the HkStack object try: hkstack = HkStack(rfRstream, rfV2=rfRstream_copy, strike=args.strike, dip=args.dip, vp=args.vp) except: hkstack = HkStack(rfRstream, strike=args.strike, dip=args.dip, vp=args.vp) # Update attributes hkstack.hbound = args.hbound hkstack.kbound = args.kbound hkstack.dh = args.dh hkstack.dk = args.dk hkstack.weights = args.weights # Stack with or without dip if args.calc_dip: hkstack.stack_dip() else: hkstack.stack() # Average stacks hkstack.average(typ=args.typ) if args.plot: hkstack.plot(args.save_plot, args.title, args.form) if args.save: filename = savepath / (hkstack.rfV1[0].stats.station + \ ".hkstack."+args.typ+".pkl") hkstack.save(file=filename)
def test_getInventory(self): """ Testing inventory requests. """ client = Client(user='******') dt1 = UTCDateTime("1974-01-01T00:00:00") dt2 = UTCDateTime("2011-01-01T00:00:00") # 1 - XML w/ instruments result = client.getInventory('GE', 'SNAA', '', 'BHZ', dt1, dt2, format='XML') self.assertTrue(result.startswith('<?xml')) self.assertTrue('code="GE"' in result) # 2 - SUDS object w/o instruments result = client.getInventory('GE', 'SNAA', '', 'BHZ', dt1, dt2, instruments=False) self.assertTrue(isinstance(result, object)) self.assertEqual(result.ArclinkInventory.inventory.network._code, 'GE') # 3 - SUDS object w/ instruments result = client.getInventory('GE', 'SNAA', '', 'BHZ', dt1, dt2, instruments=True) self.assertTrue(isinstance(result, object)) self.assertEqual(result.ArclinkInventory.inventory.network._code, 'GE') self.assertTrue('sensor' in result.ArclinkInventory.inventory) self.assertTrue('responsePAZ' in result.ArclinkInventory.inventory) # 4 - SUDS object with spatial filters client = Client(user='******') result = client.getInventory('GE', 'SNAA', '', 'BHZ', dt1, dt2, min_latitude=-72.0, max_latitude=-71.0, min_longitude=-3, max_longitude=-2) self.assertTrue(isinstance(result, object)) self.assertEqual(result.ArclinkInventory.inventory.network._code, 'GE') # 5 - SUDS object with spatial filters with incorrect coordinates client = Client(user='******') result = client.getInventory('GE', 'SNAA', '', 'BHZ', dt1, dt2, min_latitude=-71.0, max_latitude=-72.0, min_longitude=-2, max_longitude=-3) self.assertTrue(isinstance(result, object)) self.assertEqual(result.ArclinkInventory.inventory.network._code, 'GE')
def pick_ident(self): """ Clean false picks and Make picks. """ scnl = SCNL([ self.stats.station, self.stats.channel, self.stats.network, self.stats.location ]) dt = self.stats.delta npts_Tma = int(round(self.picker.t_ma / dt, 0)) LEN = self.stats.npts # trigger the earthquakes trigger_ptnl_index = np.where( self.summary[npts_Tma:LEN] > self.thres[npts_Tma:LEN]) trigger_ptnl_index = trigger_ptnl_index + np.array(npts_Tma) t = np.arange(0, self.stats.npts / self.stats.sampling_rate, dt) trigger_ptnl = t[trigger_ptnl_index][0] # clean close picks window_t_up = int(round(self.picker.t_up / dt, 0)) trigger_remove1_index = [] for i in range(0, len(trigger_ptnl) - 1): # second from last if (trigger_ptnl[i + 1] - trigger_ptnl[i] ) <= window_t_up * dt: # avoid consecutive picking trigger_remove1_index.append(i + 1) # delete close picks trigger_ptnl = np.delete(trigger_ptnl, trigger_remove1_index) # clean_filtering trigger_remove2_index = [] N = self.picker.nr_coeff filter_length = self.picker.nr_len for i in range(len(trigger_ptnl)): # determine filter_length for each pick: r, R = self.winlen(i, trigger_ptnl, filter_length, t, dt) M = min(r, R) if N * np.std( self.tr.data[int(round(trigger_ptnl[i] / dt, 0)) - M:int(round(trigger_ptnl[i] / dt, 0))] ) >= np.std( self.tr[int(round(trigger_ptnl[i] / dt, 0) ):int(round(trigger_ptnl[i] / dt, 0)) + M]): trigger_remove2_index.append(i) # delete fake picks trigger_ptnl = np.delete(trigger_ptnl, trigger_remove2_index) # assign potential picks to trigger trigger = trigger_ptnl # really need to be careful copy list or array, since if just copy like A=B, when any element in B changes, A will change as well # roll backward for picking picks = [] for i in range(len(trigger)): index = int(round(trigger[i] / dt, 0)) while True: if self.summary[index] > self.summary[index - 1]: index -= 1 else: break picks.append( UTCDateTime(self.tr.stats.starttime + round(t[index], 3))) # really need to be careful copy list or array, since if just copy like A=B, when any element in B changes, A will change as well # roll forward for maximum signal values maxes = copy.deepcopy(trigger) for i in range(len(trigger)): index = int(round(trigger[i] / dt, 0)) while True: if self.summary[index] < self.summary[index + 1]: index += 1 else: break maxes[i] = round(self.summary[index], 3) # really need to be careful copy list or array, since if just copy like A=B, when any element in B changes, A will change as well # Signal noise ration: SNR SNR = copy.deepcopy(trigger) for i in range(len(picks)): index = int(round(trigger[i] / dt, 0)) noise = rms(self.summary[index - npts_Tma:index]) SNR[i] = round(maxes[i] / noise, 1) return scnl, picks, trigger, SNR
# # Convert to NumPy character array # data = np.fromstring(sl_data, dtype='|S1') # print(data) # Fill header attributes stats = { 'network': 'BW', 'station': 'RJOB', 'location': 'ASD', 'channel': 'SHZ', 'npts': len(data), 'sampling_rate': 100, 'mseed': { 'dataquality': 'D' }, 'starttime': UTCDateTime(str(sl_header_start_time)) } # set current time #stats['starttime'] = UTCDateTime() st = Stream([Trace(data=data, header=stats)]) # write as ASCII file (encoding=0) #outfile_name += ".mseed" #st.write(outfile_name, format='MSEED', encoding=0, reclen=256) st.write(outfile_name, format='MSEED', encoding=11, reclen=256, byteorder='>') # Show that it worked, convert NumPy character array back to string st1 = read(outfile_name)
from obspy.core import UTCDateTime import matplotlib.pyplot as plt import numpy as np f = open('ALQ_Results.csv','r') times = [] ws = [] ls = [] wg = [] lg = [] sig2 = [] resi = [] for line in f: line = line.split(', ') time = UTCDateTime('19' + line[3] + '-' + line[1] + '-' + line[2] + 'T00:00:00') times.append(time.year + float(time.julday)/365.25) ws.append(float(line[5])) ls.append(float(line[6])) wg.append(float(line[7])) lg.append(float(line[8])) sig2.append(float(line[9])) resi.append(float(line[11])) f.close() import matplotlib as mpl # Importing and applying font mpl.rc('font', family = 'serif')
#!/usr/bin/python import numpy as np import scipy.signal as signal from mpi4py import MPI from copy import deepcopy from obspy.core import UTCDateTime, stream, trace import obspy.signal as osignal from miic.core.corr_fun import combine_stats import matplotlib.pyplot as plt zerotime = UTCDateTime(1971, 1, 1) def pxcorr(comm, A, **kwargs): """ A is an array with time along going the first dimension. """ global zerotime t0 = MPI.Wtime() msize = A.shape ntrc = msize[1] psize = comm.Get_size() rank = comm.Get_rank() # time domain processing # map of traces on precesses pmap = (np.arange(ntrc) * psize) / ntrc
from obspy.core import UTCDateTime years = range(2011, 2061) for year in years: t_bd = UTCDateTime(year, 7, 9) party = t_bd + (24 * 60 * 60) while party.isoweekday() != 5: party += 24 * 60 * 60 print year, "the party is on", party.date t = UTCDateTime() count = 0 while t.year < 2013: t += 24 * 60 * 60 if t.weekday() == 4 and t.day == 13: count += 1 print t.date, "is a friday 13th" print count, "days to take off"
def preproc_data(filename='out_from_parse_dbselect', to_file=False, num_lines=2, **ev_id): #df = pd.read_pickle(filename) if ev_id: df = filename[filename['id'] == ev_id['ev_id']] else: df = filename.iloc[:num_lines] df = df.reset_index(drop=True) pdf = None count = 0 duration = 5 * 60 for i in range(len(df)): data = { 'x': [], 'y': [], 'chan': [], 'net': [], 'station': [], 'datetime': [], 'depth': [], 'dsize': [], 'id': [], 'impulsive': [], 'evlo': [], 'evla': [], 'mag': [], 'type': [], 'weight': [], 'stlo': [], 'stla': [], 'lbl': [], 'dist': [] } chan = df['chan'][i] evlo = df['lon'][i] evla = df['lat'][i] #chan = str(chan[0]+'H?') #print(count) try: tr = client.get_waveforms( station=df['station'][i], network=df['net'][i], channel='*', location='*', starttime=UTCDateTime(df['datetime'][i]) - 10, endtime=UTCDateTime(df['datetime'][i]) + duration, attach_response=True) inv = client.get_stations( starttime=UTCDateTime(df['datetime'][i]) - 10, endtime=UTCDateTime(df['datetime'][i]) + duration, station=df.station[i], network=df.net[i], location='*', channel='*', level='response') tr = tr.select(channel='[E,H,B]H?') if len(tr) > 3: tr = tr.select(channel='H??') tr.merge(fill_value=0) #tr = tr.remove_sensitivity() tr.remove_response(inventory=inv, pre_filt=pre_filt) tr.resample(100) tr.detrend() tr.taper(.01) if len(tr) == 1: stla, stlo, dist = rotater_single(tr, inv, evlo, evla) tr.filter('highpass', freq=1.0) f, t, S0 = spectrogram(tr[0].data, tr[0].stats.sampling_rate) S1 = np.zeros_like(S0) data['x'].append( np.array([ S0[3:51, 1:41] / np.max(S0[3:51, 1:41]), S1[3:51, 1:41], S1[3:51, 1:41] ])) data['dsize'] = 'single' elif len(tr) == 3: trn, stla, stlo, dist = rotater(tr, inv, evlo, evla) trn.filter('highpass', freq=1.0) f, t, S0 = spectrogram(trn[0].data, trn[0].stats.sampling_rate) f, t, S1 = spectrogram(trn[1].data, trn[1].stats.sampling_rate) f, t, S2 = spectrogram(trn[2].data, trn[2].stats.sampling_rate) data['x'].append( np.array([ S0[3:51, 1:41] / np.max(S0[3:51, 1:41]), S1[3:51, 1:41] / np.max(S1[3:51, 1:41]), S2[3:51, 1:41] / np.max(S2[3:51, 1:41]) ])) data['dsize'] = 'tri' tmp = df.loc[i] tmp.stla = stla tmp.stlo = stlo tmp.dist = dist data['station'].append(tmp.station) data['chan'].append(tmp.chan) data['net'].append(tmp.net) data['evlo'].append(tmp.lon) data['evla'].append(tmp.lat) data['datetime'].append(tmp.datetime) data['depth'].append(tmp.depth) data['mag'].append(tmp.mag) data['id'].append(tmp.id) data['type'].append(tmp.type) data['weight'].append(tmp.weight) data['impulsive'].append(tmp.impulsive) data['stla'].append(tmp.stla) data['stlo'].append(tmp.stlo) data['dist'].append(tmp.dist) if tmp.type == 'le': data['y'].append([1, 0]) data['lbl'].append(0) elif tmp.type == 'qb': data['y'].append([0, 1]) data['lbl'].append(1) if pdf is None: pdf = pd.DataFrame(data) else: pdf = pdf.append(pd.DataFrame(data)) count += 1 except: #ValueError : print(i) pdf = pdf.reset_index(drop=True) predictions1 = model.predict( np.array([scale_transform(x) for x in pdf['x']])) pred1 = np.argmax(predictions1, axis=1) pdf['predictions'] = [np.array(x) for x in predictions1] pdf['preds'] = pred1 num_events = len(set(pdf['id'])) #pdf[pdf['pred'] != pdf['lbl']] print('sucessfully processed ' + str(count) + ' examples from ' + str(num_events) + ' events') if to_file == True: stg = 'proc_' + filename pdf.to_pickle(stg) pdf = None else: return pdf
class SeedlinkPlotter(Tkinter.Tk): """ This module plots realtime seismic data from a Seedlink server """ def __init__(self, stream=None, events=None, myargs=None, lock=None, drum_plot=True, trace_ids=None, *args, **kwargs): Tkinter.Tk.__init__(self, *args, **kwargs) favicon = Tkinter.PhotoImage( file=os.path.join(os.path.dirname(os.path.abspath(__file__)), "favicon.gif")) self.tk.call('wm', 'iconphoto', self._w, favicon) self.wm_title("seedlink-plotter {}".format(myargs.seedlink_server)) self.focus_set() self._bind_keys() args = myargs self.lock = lock ### size and position self.geometry(str(args.x_size) + 'x' + str(args.y_size) + '+' + str( args.x_position) + '+' + str(args.y_position)) w, h, pad = self.winfo_screenwidth(), self.winfo_screenheight(), 3 self._geometry = ("%ix%i+0+0" % (w - pad, h - pad)) # hide the window decoration if args.without_decoration: self.wm_overrideredirect(True) if args.fullscreen: self._toggle_fullscreen(None) # main figure self.figure = Figure() canvas = FigureCanvasTkAgg(self.figure, master=self) canvas.show() canvas.get_tk_widget().pack(fill=Tkinter.BOTH, expand=1) self.backtrace = args.backtrace_time self.canvas = canvas self.scale = args.scale self.args = args self.stream = stream self.events = events self.drum_plot = drum_plot self.ids = trace_ids # Colors if args.rainbow: # Rainbow colors ! self.color = self.rainbow_color_generator( int(args.nb_rainbow_colors)) else: # Regular colors: Black, Red, Blue, Green self.color = ('#000000', '#e50000', '#0000e5', '#448630') self.plot_graph() def _quit(self, event): event.widget.quit() def _bind_keys(self): self.bind('<Escape>', self._quit) self.bind('q', self._quit) self.bind('f', self._toggle_fullscreen) def _toggle_fullscreen(self, event): g = self.geometry() self.geometry(self._geometry) self._geometry = g def plot_graph(self): now = UTCDateTime() if self.drum_plot: self.stop_time = UTCDateTime( now.year, now.month, now.day, now.hour, 0, 0) + 3600 self.start_time = self.stop_time - self.args.backtrace_time else: self.start_time = now - self.backtrace self.stop_time = now with self.lock: # leave some data left of our start for possible processing self.stream.trim( starttime=self.start_time - 120, nearest_sample=False) stream = self.stream.copy() try: logging.info(str(stream.split())) if not stream: raise Exception("Empty stream for plotting") if self.drum_plot or OBSPY_VERSION < [0, 10]: stream.merge() stream.trim(starttime=self.start_time, endtime=self.stop_time, pad=True, nearest_sample=False) else: stream.merge(-1) stream.trim(starttime=self.start_time, endtime=self.stop_time) if self.drum_plot: self.plot_drum(stream) else: self.plot_lines(stream) except Exception as e: logging.error(e) pass self.after(int(self.args.update_time * 1000), self.plot_graph) def plot_drum(self, stream): title = stream[0].id if self.scale: title += ' - scale: ' + str(self.scale) + ' -' else: title += ' - autoscale -' title += " without filtering" self.figure.clear() stream.plot( fig=self.figure, type='dayplot', interval=self.args.x_scale, number_of_ticks=self.args.time_tick_nb, tick_format=self.args.tick_format, size=(self.args.x_size, self.args.y_size), x_labels_size=8, y_labels_size=8, title=title, title_size=14, linewidth=0.5, right_vertical_labels=False, vertical_scaling_range=self.args.scale, subplots_adjust_left=0.04, subplots_adjust_right=0.99, subplots_adjust_top=0.95, subplots_adjust_bottom=0.05, one_tick_per_line=True, color=self.color, show_y_UTC_label=False, events=self.events) def plot_lines(self, stream): for id_ in self.ids: if not any([tr.id == id_ for tr in stream]): net, sta, loc, cha = id_.split(".") header = {'network': net, 'station': sta, 'location': loc, 'channel': cha, 'starttime': self.start_time} data = np.zeros(2) stream.append(Trace(data=data, header=header)) stream.sort() self.figure.clear() fig = self.figure # avoid the differing trace.processing attributes prohibiting to plot # single traces of one id together. for tr in stream: tr.stats.processing = [] stream.plot(fig=fig, method="fast", draw=False, equal_scale=False, size=(self.args.x_size, self.args.y_size), title="", color='Blue', tick_format=self.args.tick_format, number_of_ticks=self.args.time_tick_nb) fig.subplots_adjust(left=0, right=1, top=1, bottom=0) bbox = dict(boxstyle="round", fc="w", alpha=0.8) path_effects = [withStroke(linewidth=4, foreground="w")] pad = 10 for ax in fig.axes[::2]: ax.set_axis_bgcolor("0.8") for id_, ax in zip(self.ids, fig.axes): ax.set_title("") if OBSPY_VERSION < [0, 10]: ax.text(0.1, 0.9, id_, va="top", ha="left", transform=ax.transAxes, bbox=bbox, size=self.args.title_size) xlabels = ax.get_xticklabels() ylabels = ax.get_yticklabels() plt.setp(ylabels, ha="left", path_effects=path_effects) ax.yaxis.set_tick_params(pad=-pad) # treatment for bottom axes: if ax is fig.axes[-1]: plt.setp( xlabels, va="bottom", size=self.args.time_legend_size, bbox=bbox) if OBSPY_VERSION < [0, 10]: plt.setp(xlabels[:1], ha="left") plt.setp(xlabels[-1:], ha="right") ax.xaxis.set_tick_params(pad=-pad) # all other axes else: plt.setp(xlabels, visible=False) locator = MaxNLocator(nbins=4, prune="both") ax.yaxis.set_major_locator(locator) ax.yaxis.grid(False) ax.grid(True, axis="x") if len(ax.lines) == 1: ydata = ax.lines[0].get_ydata() # if station has no data we add a dummy trace and we end up in # a line with either 2 or 4 zeros (2 if dummy line is cut off # at left edge of time axis) if len(ydata) in [4, 2] and not ydata.any(): plt.setp(ylabels, visible=False) ax.set_axis_bgcolor("#ff6666") if OBSPY_VERSION >= [0, 10]: fig.axes[0].set_xlim(right=date2num(self.stop_time.datetime)) fig.axes[0].set_xlim(left=date2num(self.start_time.datetime)) if len(fig.axes) > 5: bbox["alpha"] = 0.6 fig.text(0.99, 0.97, self.stop_time.strftime("%Y-%m-%d %H:%M:%S UTC"), ha="right", va="top", bbox=bbox, fontsize="medium") fig.canvas.draw() def rgb_to_hex(self, red_value, green_value, blue_value): """ converter for the colors gradient """ return '#%02X%02X%02X' % (red_value, green_value, blue_value) def rainbow_color_generator(self, max_color): """ Rainbow color generator """ color_list = [] frequency = 0.3 for compteur_lignes in xrange(max_color): red = sin(frequency * compteur_lignes * 2 + 0) * 127 + 128 green = sin(frequency * compteur_lignes * 2 + 2) * 127 + 128 blue = sin(frequency * compteur_lignes * 2 + 4) * 127 + 128 color_list.append( self.rgb_to_hex(red_value=red, green_value=green, blue_value=blue)) return tuple(color_list)
from obspy.core import UTCDateTime from obspy.arclink import Client client = Client() t = UTCDateTime("2008-04-17T16:00:00Z") st = client.getWaveform("BW", "HROE", "", "EH*", t, t + 10 * 60) print st st.plot() from obspy.neries import Client client = Client() events = client.getEvents(min_datetime="2008-10-10T08:05:00Z", max_datetime="2008-10-10T08:15:00Z") print events event = events[0] print "origin time is", event['datetime'] print "magnitude is", event['magnitude'] print "longitude is", event['longitude'] print "latitude is", event['latitude'] print "depth is", event['depth']
from obspy import Stream,Trace from numpy import genfromtxt,r_,array from glob import glob from obspy.core import UTCDateTime from obspy import read from mudpy.forward import highpass from scipy.integrate import cumtrapz from matplotlib import pyplot as plt from datetime import datetime from string import replace stafile='/Users/dmelgar/Amatrice2016/M6.6/strong_motion/stations/latest.sta' fsta=open(stafile,'w') rootpath='/Users/dmelgar/Amatrice2016/M6.6/strong_motion/' fcorner=[1./20,0.4] time_epi=UTCDateTime('2016-10-30T06:40:19') tcut=15 tprevious=5 v_or_d='v' makesac=True signalprocess=False makeplots_raw=False makemudpy=False makeplots_proc=False def bandpass_filter(data,fcorner,fsample,order): ''' Make a lowpass zero phase filter ''' from numpy import size,array
def extract_data(self, index_rows): """ Perform the data extraction. :param index_rows: requested data, as produced by `HTTPServer_RequestHandler.fetch_index_rows` :yields: sequence of `ExtractedDataSegment`s """ # Pre-scan the index rows: # 1) Build processed list for extraction # 2) Check if the request is small enough to satisfy # Note: accumulated estimate of output bytes will be equal to or higher than actual output total_bytes = 0 request_rows = [] Request = namedtuple('Request', [ 'srcname', 'filename', 'starttime', 'endtime', 'triminfo', 'bytes', 'samplerate' ]) try: for NRow in index_rows: srcname = "_".join(NRow[:4]) filename = NRow.filename logger.debug("EXTRACT: src=%s, file=%s, bytes=%s, rate:%s" % (srcname, filename, NRow.bytes, NRow.samplerate)) starttime = UTCDateTime(NRow.requeststart) endtime = UTCDateTime(NRow.requestend) triminfo = self.handle_trimming(starttime, endtime, NRow) total_bytes += triminfo[1][1] - triminfo[0][1] if self.request_limit > 0 and total_bytes > self.request_limit: raise RequestLimitExceededError( "Result exceeds limit of %d bytes" % self.request_limit) if self.dp_replace_re: filename = self.dp_replace_re.sub(self.dp_replace_sub, filename) if not os.path.exists(filename): raise Exception("Data file does not exist: %s" % filename) request_rows.append( Request(srcname=srcname, filename=filename, starttime=starttime, endtime=endtime, triminfo=triminfo, bytes=NRow.bytes, samplerate=NRow.samplerate)) logger.debug("EXTRACT: src=%s, file=%s, bytes=%s, rate:%s" % (srcname, filename, NRow.bytes, NRow.samplerate)) except Exception as err: import traceback traceback.print_exc() raise Exception("Error accessing data index: %s" % str(err)) # Error if request matches no data if total_bytes == 0: raise NoDataError() # Get & return the actual data for NRow in request_rows: logger.debug( "Extracting %s (%s - %s) from %s" % (NRow.srcname, NRow.starttime, NRow.endtime, NRow.filename)) # Iterate through records in section if only part of the section is needed if NRow.triminfo[0][2] or NRow.triminfo[1][2]: for msri in MSR_iterator(filename=NRow.filename, startoffset=NRow.triminfo[0][1], dataflag=False): offset = msri.get_offset() # Done if we are beyond end offset if offset >= NRow.triminfo[1][1]: break yield MSRIDataSegment(msri, NRow.samplerate, NRow.starttime, NRow.endtime, NRow.srcname) # Check for passing end offset if (offset + msri.msr.contents.reclen) >= NRow.triminfo[1][1]: break # Otherwise, return the entire section else: yield FileDataSegment(NRow.filename, NRow.triminfo[0][1], NRow.bytes, NRow.srcname)
# state file base (Observatory code and channel will be appended to this) state_dir = 'PriorState/' # state_file = 'SvSqDistState' state_file = None # The following define an allowed minimum age for requested data, and a set # of discrete times (within a day) at which endtime may fall. Actual endtime # and startime values will be calculated in the code. min_obs_age = 600 # in seconds every_nth_sec = 300 # in seconds # if custom interval is required, modify the following lines to override the # realtime interval calcualted from min_obs_age and every_nth_sec, otherwise # set starttime and endtime equal to None starttime = UTCDateTime(2020, 4, 20, 9, 0, 0) endtime = UTCDateTime(2020, 4, 20, 12, 0, 0) #starttime = None #endtime = None # # # No more configuration parameters below this point # # # create folders for downloads and output if they don't exist already # (function catches race condition if path is created after check) def mkdirp(path): import os
from matplotlib import pyplot as plt from obspy import read from numpy import genfromtxt from obspy.core import UTCDateTime #Plot acceleration stations = genfromtxt( '/Users/dmelgar/Slip_inv/wenc_2008/data/station_info/wenc.gflist', usecols=0, dtype='S') stations = stations[5:] path = '/Users/dmelgar/Slip_inv/wenc_2008/' time_epi = UTCDateTime('2008-05-12T06:28:04') for k in range(len(stations)): sta = stations[k] print sta n = read(path + 'data/waveforms/' + sta + '.vel.n') e = read(path + 'data/waveforms/' + sta + '.vel.e') u = read(path + 'data/waveforms/' + sta + '.vel.u') n.trim(starttime=time_epi) e.trim(starttime=time_epi) u.trim(starttime=time_epi) plt.figure() plt.subplot(311) plt.title(sta) plt.plot(n[0].times(), n[0].data) plt.ylabel('North (m/s)') plt.subplot(312) plt.plot(e[0].times(), e[0].data)
Sspeed = 1000 #S-wave mask tmax = timedelta(seconds=2. * 60) minpgd = 0.03 #in m maxdist = 500 #in km minsta = 2 Nboot = 1000 hypo = [20.6002, 38.6655, 10.7] #Get PGD as a function of time for all sites if get_pgd: #initalize event = 'lefkada' print event #Get hypocenter time hypo_time = UTCDateTime( genfromtxt(path + 'event_info/' + event + '.hypo', dtype='S')[0]) #Read station data stanames = genfromtxt(path + 'station_info/lefkada.sta', usecols=0, dtype='S') station_coords = genfromtxt(path + 'station_info/lefkada.sta', usecols=[1, 2]) #Now loop over station data at each epoch for ksta in range(len(stanames)): #print '... fetching PGD for '+stanames[ksta] try: n = read(data_path + '/' + stanames[ksta] + '.LXN.sac') e = read(data_path + '/' + stanames[ksta] + '.LXE.sac') u = read(data_path + '/' + stanames[ksta] + '.LXZ.sac') if n[0].stats.npts > 0: #Trim to times of interest
def test_default_inputs(): input_dics = test_read_input_command() assert os.path.basename(input_dics['datapath']) == 'obspydmt-data' assert input_dics['event_based'] is True assert input_dics['data_source'] == ['IRIS'] assert input_dics['waveform'] is True assert input_dics['response'] is True assert input_dics['dir_select'] is False assert input_dics['list_stas'] is False assert input_dics['min_epi'] is False assert input_dics['max_epi'] is False assert input_dics['min_azi'] is False assert input_dics['max_azi'] is False assert input_dics['test'] is False assert (UTCDateTime(input_dics['max_date']) - UTCDateTime(input_dics['min_date']) > (60 * 60 * 24 * 365 * 45)) assert input_dics['preset'] == 0.0 assert input_dics['offset'] == 1800.0 assert input_dics['waveform_format'] is False assert input_dics['resample_method'] == 'lanczos' assert input_dics['sampling_rate'] is False assert input_dics['net'] == '*' assert input_dics['sta'] == '*' assert input_dics['loc'] == '*' assert input_dics['cha'] == '*' assert input_dics['lat_cba'] is None assert input_dics['lon_cba'] is None assert input_dics['mr_cba'] is None assert input_dics['Mr_cba'] is None assert input_dics['mlat_rbb'] is None assert input_dics['Mlat_rbb'] is None assert input_dics['mlon_rbb'] is None assert input_dics['Mlon_rbb'] is None assert input_dics['req_np'] == 4 assert input_dics['process_np'] == 4 assert input_dics['username'] is None assert input_dics['password'] is None assert input_dics['event_catalog'] == 'LOCAL' assert input_dics['min_depth'] == -10.0 assert input_dics['max_depth'] == +6000.0 assert input_dics['min_mag'] == 3.0 assert input_dics['max_mag'] == 10. assert input_dics['mag_type'] is None assert input_dics['evlatmin'] is None assert input_dics['evlatmax'] is None assert input_dics['evlonmin'] is None assert input_dics['evlonmax'] is None assert input_dics['evlat'] is None assert input_dics['evlon'] is None assert input_dics['evradmin'] is None assert input_dics['evradmax'] is None assert input_dics['interval'] == 3600 * 24 assert input_dics['pre_process'] == 'process_unit' assert input_dics['select_data'] is False assert input_dics['corr_unit'] == 'DIS' assert input_dics['pre_filt'] == '(0.008, 0.012, 3.0, 4.0)' assert input_dics['water_level'] == 600.0 assert input_dics['plot_dir_name'] == 'raw' assert input_dics['plot_save'] is False assert input_dics['plot_format'] is False assert input_dics['show_no_plot'] is None assert input_dics['plot_lon0'] == 180 assert input_dics['plot_style'] == 'simple' assert input_dics['plotxml_date'] is False assert input_dics['plotxml_start_stage'] == 1 assert input_dics['plotxml_end_stage'] == 100 assert input_dics['plotxml_min_freq'] == 0.01 assert input_dics['plotxml_percentage'] == 80 assert input_dics['plotxml_phase_threshold'] == 10. assert input_dics['plotxml_output'] == 'VEL' assert input_dics['email'] is False assert input_dics['arc_avai_timeout'] == 40 assert input_dics['arc_wave_timeout'] == 2
def main(): print() print( "################################################################################" ) print( "# __ _ _ #" ) print( "# _ __ / _|_ __ _ _ | |__ __ _ _ __ _ __ ___ ___ _ __ (_) ___ ___ #" ) print( "# | '__| |_| '_ \| | | | | '_ \ / _` | '__| '_ ` _ \ / _ \| '_ \| |/ __/ __| #" ) print( "# | | | _| |_) | |_| | | | | | (_| | | | | | | | | (_) | | | | | (__\__ \ #" ) print( "# |_| |_| | .__/ \__, |___|_| |_|\__,_|_| |_| |_| |_|\___/|_| |_|_|\___|___/ #" ) print( "# |_| |___/_____| #" ) print( "# #" ) print( "################################################################################" ) print() # Run Input Parser args = arguments.get_harmonics_arguments() # Load Database db = stdb.io.load_db(fname=args.indb) # Construct station key loop allkeys = db.keys() sorted(allkeys) # Extract key subset if len(args.stkeys) > 0: stkeys = [] for skey in args.stkeys: stkeys.extend([s for s in allkeys if skey in s]) else: stkeys = db.keys() sorted(stkeys) # Loop over station keys for stkey in list(stkeys): # Extract station information from dictionary sta = db[stkey] # Define path to see if it exists datapath = Path('DATA') / stkey if not datapath.is_dir(): raise (Exception('Path to ' + str(datapath) + ' doesn`t exist - aborting')) # Get search start time if args.startT is None: tstart = sta.startdate else: tstart = args.startT # Get search end time if args.endT is None: tend = sta.enddate else: tend = args.endT if tstart > sta.enddate or tend < sta.startdate: continue # Temporary print locations tlocs = sta.location if len(tlocs) == 0: tlocs = [''] for il in range(0, len(tlocs)): if len(tlocs[il]) == 0: tlocs[il] = "--" sta.location = tlocs # Update Display print(" ") print(" ") print("|===============================================|") print("|===============================================|") print("| {0:>8s} |".format( sta.station)) print("|===============================================|") print("|===============================================|") print("| Station: {0:>2s}.{1:5s} |".format( sta.network, sta.station)) print("| Channel: {0:2s}; Locations: {1:15s} |".format( sta.channel, ",".join(tlocs))) print("| Lon: {0:7.2f}; Lat: {1:6.2f} |".format( sta.longitude, sta.latitude)) print("| Start time: {0:19s} |".format( sta.startdate.strftime("%Y-%m-%d %H:%M:%S"))) print("| End time: {0:19s} |".format( sta.enddate.strftime("%Y-%m-%d %H:%M:%S"))) print("|-----------------------------------------------|") rfRstream = Stream() rfTstream = Stream() datafiles = [x for x in datapath.iterdir() if x.is_dir()] for folder in datafiles: # Skip hidden folders if folder.name.startswith('.'): continue date = folder.name.split('_')[0] year = date[0:4] month = date[4:6] day = date[6:8] dateUTC = UTCDateTime(year + '-' + month + '-' + day) if dateUTC > tstart and dateUTC < tend: filename = folder / "RF_Data.pkl" if filename.is_file(): file = open(filename, "rb") rfdata = pickle.load(file) if rfdata[0].stats.snrh > args.snrh and rfdata[0].stats.snr and \ rfdata[0].stats.cc > args.cc: rfRstream.append(rfdata[1]) rfTstream.append(rfdata[2]) file.close() else: continue if args.no_outl: # Remove outliers wrt variance varR = np.array([np.var(tr.data) for tr in rfRstream]) # Calculate outliers medvarR = np.median(varR) madvarR = 1.4826 * np.median(np.abs(varR - medvarR)) robustR = np.abs((varR - medvarR) / madvarR) outliersR = np.arange(len(rfRstream))[robustR > 2.] for i in outliersR[::-1]: rfRstream.remove(rfRstream[i]) rfTstream.remove(rfTstream[i]) # Do the same for transverse varT = np.array([np.var(tr.data) for tr in rfTstream]) medvarT = np.median(varT) madvarT = 1.4826 * np.median(np.abs(varT - medvarT)) robustT = np.abs((varT - medvarT) / madvarT) outliersT = np.arange(len(rfTstream))[robustT > 2.] for i in outliersT[::-1]: rfRstream.remove(rfRstream[i]) rfTstream.remove(rfTstream[i]) # Try binning if specified if args.nbin is not None: rf_tmp = binning.bin(rfRstream, rfTstream, typ='baz', nbin=args.nbin + 1) rfRstream = rf_tmp[0] rfTstream = rf_tmp[1] # Filter original streams rfRstream.filter('bandpass', freqmin=args.bp[0], freqmax=args.bp[1], corners=2, zerophase=True) rfTstream.filter('bandpass', freqmin=args.bp[0], freqmax=args.bp[1], corners=2, zerophase=True) # Initialize the HkStack object harmonics = Harmonics(rfRstream, rfTstream) # Stack with or without dip if args.find_azim: harmonics.dcomp_find_azim(xmin=args.trange[0], xmax=args.trange[1]) print("Optimal azimuth for trange between " + str(args.trange[0]) + " and " + str(args.trange[1]) + "is: " + str(harmonics.azim)) else: harmonics.dcomp_fix_azim(azim=args.azim) if args.plot: harmonics.plot(args.ymax, args.scale, args.save_plot, args.title, args.form) if args.save: filename = datapath / (hkstack.hstream[0].stats.station + ".harmonics.pkl") harmonics.save()
# decide if it is high-frequency or not HF = True chans = ['HHZ', 'HHE', 'HHN'] fig = plt.figure(1, figsize=(12, 12)) plt.subplots_adjust(hspace=0.001) for idx, chan in enumerate(chans): st = Stream() for s in range(1, 9): if debug: print('On ' + str(s) + ' ' + chan) st += read(string + str(s) + '/' + chan + '.D/XX*') stime = UTCDateTime('2017-05-03T01:10:00.0') etime = UTCDateTime('2017-05-03T02:10:00.0') st.trim(starttime=stime, endtime=etime) nsHF, psHF, fHF = selfnoise(st) st.decimate(5) st.decimate(2) st.decimate(5) print(st) ns, ps, f = selfnoise(st) #st.plot() if chan == 'HHE':
def preprocessing_function_asdf(dir_obs,eventname,time_increment,end_time,min_period,max_period): processdir=eventname+'preprocessed' processdata='preprocessed_'+ str(min_period) +'s_to_'+str(max_period)+'s.h5' tag_name='preprocessed_'+ str(min_period) +'s_to_'+str(max_period)+'s' if os.path.exists(processdir+'/'+processdata): os.system('rm -rf'+' '+processdir+'/'+processdata) # os.makedirs(processdir) os.system('cp'+' '+dir_obs+' '+processdir+'/'+processdata) def zerophase_chebychev_lowpass_filter(trace, freqmax): """ Custom Chebychev type two zerophase lowpass filter useful for decimation filtering. This filter is stable up to a reduction in frequency with a factor of 10. If more reduction is desired, simply decimate in steps. Partly based on a filter in ObsPy. :param trace: The trace to be filtered. :param freqmax: The desired lowpass frequency. Will be replaced once ObsPy has a proper decimation filter. """ # rp - maximum ripple of passband, rs - attenuation of stopband rp, rs, order = 1, 96, 1e99 ws = freqmax / (trace.stats.sampling_rate * 0.5) # stop band frequency wp = ws # pass band frequency while True: if order <= 12: break wp *= 0.99 order, wn = signal.cheb2ord(wp, ws, rp, rs, analog=0) b, a = signal.cheby2(order, rs, wn, btype="low", analog=0, output="ba") print(trace) # Apply twice to get rid of the phase distortion. trace.data = signal.filtfilt(b, a, trace.data) # ========================================================================= # Read ASDF file # ========================================================================= ds = pyasdf.ASDFDataSet(processdir+'/'+processdata) print(ds) list=ds.waveforms.list() event = ds.events[0] dt=time_increment sampling_rate = 1.0 / dt start_time = -time_increment npts=int(round((end_time -start_time)/time_increment) + 1) origin=event.preferred_origin() or event.origins[0] print(origin.time,start_time) start=UTCDateTime(origin.time) print(start+start_time) starttime=start_time + np.float(start) print(starttime) endtime = end_time+starttime duration = end_time -start_time f2 = 0.9 / max_period f3 = 1.1 / min_period # Recommendations from the SAC manual. f1 = 0.5 * f2 f4 = 2.0 * f3 pre_filt = (f1, f2, f3, f4) for _i,stid in enumerate(list): #print(stid) stla,stlo,evz=ds.waveforms[stid].coordinates.values() st=ds.waveforms[stid].raw_recording for tr in st: print(tr) # Trim to reduce processing costs #tr.trim(starttime - 0.2 * duration, endtime + 0.2 * duration) print(tr) while True: decimation_factor = int(dt / tr.stats.delta) # Decimate in steps for large sample rate reductions. if decimation_factor > 8: decimation_factor = 8 if decimation_factor > 1: new_nyquist = tr.stats.sampling_rate / 2.0 / float( decimation_factor) #print(new_nyquist) zerophase_chebychev_lowpass_filter(tr, new_nyquist) print(tr) tr.decimate(factor=decimation_factor, no_filter=True) else: break inv=ds.waveforms[stid].StationXML # Detrend and taper #print('start') st.detrend("linear") st.detrend("demean") st.taper(max_percentage=0.05, type="hann") # Instrument correction try: st.attach_response(inv) st.remove_response(output="DISP", pre_filt=pre_filt, zero_mean=False, taper=False) except Exception as e: net = inv.get_contents()['channels'][0].split('.', 2)[0] sta = inv.get_contents()['channels'][0].split('.', 2)[1] msg = ("Station: %s.%s could not be corrected with the help of" " asdf file: '%s'. Due to: '%s' Will be skipped.") \ % (net, sta, processing_info["asdf_input_filename"], e.__repr__()), raise LASIFError(msg) # Bandpass filtering st.detrend("linear") st.detrend("demean") st.taper(0.05, type="cosine") st.filter("bandpass", freqmin=1.0 / max_period, freqmax=1.0 / min_period, corners=3, zerophase=False) st.detrend("linear") st.detrend("demean") st.taper(0.05, type="cosine") st.filter("bandpass", freqmin=1.0 / max_period, freqmax=1.0 / min_period, corners=3, zerophase=False) # Sinc interpolation for tr in st: tr.data = np.require(tr.data, requirements="C") st.interpolate(sampling_rate=sampling_rate, method="lanczos", starttime=starttime, window="blackman", a=12, npts=npts) # Convert to single precision to save space. for tr in st: tr.data = np.require(tr.data, dtype="float32", requirements="C") ds.add_waveforms(st,tag=tag_name) del ds.waveforms[stid].raw_recording del ds.waveforms[stid].preprocess
from obspy.core import UTCDateTime from pytz import timezone try: in_path = sys.argv[1] station = sys.argv[2] except: print __doc__ raise try: tme = sys.argv[3] today = UTCDateTime(tme) t = UTCDateTime(tme) except: t = datetime.datetime.today() today = UTCDateTime() tu = t.hour tl = today.hour td = tu- tl time_label = "Std 00:00:00 UTC (+%d Std Lokalzeit)"%(int (td)) in_file = "%s/%s.WSX.D.%02d%02d%02d.0000"%(in_path,station,today.day,today.month,today.year-2000) outfile = "%s/%s_%02d%02d%02d_wet.png"%(in_path,station,today.day,today.month,today.year-2000) def moving_average(x, n, type='simple'): """
array = args.array if args.fdresults: fdresultsT = args.fdresults else: print("default table FD_RESULTS") fdresultsT = 'FD_RESULTS' if args.pfkid: pfkid = args.pfkid if args.pfdid: pfdid = args.pfdid if args.tS: t_S = UTCDateTime(args.tS) print('setting ini time:', t_S) else: t_S = None if args.tE: t_E = UTCDateTime(args.tE) print('setting end time:', t_E) else: t_E = None if args.fval: fval = args.fval print('setting fval:', fval) else: fval = 0
def savecorrs(correlation,phaseweight,n_stack,id1,id2,geoinf,\ corrname,corrtype,outdir,params=None,timestring='',startday=None,\ endday=None): #============================================================================== #- Write metadata info to sac header #- Store results #============================================================================== tr=Trace(data=correlation) tr.stats.sac={} if startday == None: startday=UTCDateTime(inp.startdate) if endday == None: endday=UTCDateTime(inp.enddate) (lat1, lon1, lat2, lon2, dist, az, baz)=geoinf # Add a preprocessing string: prepstring = get_prepstring() tr.stats.sampling_rate=inp.Fs[-1] tr.stats.starttime=UTCDateTime(2000, 01, 01)-inp.max_lag*inp.Fs[-1] tr.stats.network=id1.split('.')[0] tr.stats.station=id1.split('.')[1] tr.stats.location=id1.split('.')[2] tr.stats.channel=id1.split('.')[3] tr.stats.sac['kt2']=prepstring tr.stats.sac['kt8']=corrtype tr.stats.sac['user0']=n_stack tr.stats.sac['user1']=inp.winlen tr.stats.sac['user2']=inp.olap tr.stats.sac['b']=-inp.max_lag tr.stats.sac['e']=inp.max_lag tr.stats.sac['kt0']=startday.strftime('%Y%j') tr.stats.sac['kt1']=endday.strftime('%Y%j') tr.stats.sac['iftype']=1 tr.stats.sac['stla']=lat1 tr.stats.sac['stlo']=lon1 tr.stats.sac['kevnm']=id2.split('.')[1] tr.stats.sac['evla']=lat2 tr.stats.sac['evlo']=lon2 tr.stats.sac['dist']=dist tr.stats.sac['az']=az tr.stats.sac['baz']=baz tr.stats.sac['kuser0']=id2.split('.')[0] tr.stats.sac['kuser1']=id2.split('.')[2] tr.stats.sac['kuser2']=id2.split('.')[3] if params is not None: tr.stats.sac['user3']=params[0] tr.stats.sac['user4']=params[1] tr.stats.sac['user5']=params[2] tr.stats.sac['user6']=params[3] tr.stats.sac['user7']=params[4] tr.stats.sac['user8']=params[5] #- open file and write correlation function fileid=outdir+id1+'.'+id2+'.'+corrtype+'.'+\ corrname+timestring+'.SAC' tr.write(fileid,format='SAC') if phaseweight is not None: fileid_cwt=outdir+id1+'.'+id2+'.'+corrtype+\ '.'+corrname+timestring+'.npy' np.save(fileid_cwt,phaseweight)
def monthScale(self, top=True): """ Creates the subdivisions of the month scale. """ color = self.color2 # Shortcut to window geometry. starttime = self.env.starttime endtime = self.env.endtime time_range = float(endtime - starttime) # Pixel counts. start_x = 0 end_x = self.width x_range = end_x - start_x start_y = 15 end_y = start_y + self.subscale_height y_range = self.subscale_height # Get the number of months. if endtime.year == starttime.year: months = (endtime.month - starttime.month) + 1 else: months = 0 years = endtime.year - starttime.year # If more than one year add twelve months per year. if years > 1: months += 12 * (years - 1) # Get boundaries. months += (12 - starttime.month) + 1 months += endtime.month months_count = range(months) # Loop over all years. # Loop over every month. for month in months_count: # Get the year and month of the currently treated month. cur_month = starttime.month + month if cur_month > 12: cur_year = starttime.year + ((cur_month - 1) // 12) else: cur_year = starttime.year cur_month = cur_month % 12 # Account for weird modulo operation. if cur_month == 0: cur_month = 12 # Some variables. start_of_month = UTCDateTime(cur_year, cur_month, 1) if cur_month + 1 > 12: cur_month = 1 cur_year += 1 else: cur_month += 1 end_of_month = UTCDateTime(cur_year, cur_month, 1) # Calculate boundaries. start_frac = (start_of_month - starttime) / time_range if start_frac < 0: start_frac = 0 start = start_frac * x_range if start < 0: start = 0 start += start_x end_frac = (endtime - end_of_month) / time_range end_frac = 1.0 - end_frac if end_frac > 1.0: end_frac = 1.0 end = end_frac * x_range end = x_range - end if end > x_range: end = x_range end += start_x graph_width = (end_frac - start_frac) * x_range # Only draw every second box. if not month % 2: month_box = QtGui.QGraphicsRectItem(start, start_y, graph_width, y_range) month_box.start_frac = start_frac month_box.end_frac = end_frac month_box.setBrush(color) month_box.setZValue(-198) self.addToGroup(month_box) # Add to list for easier tracking. self.month_boxes.append(month_box) # If two narrow do not add a name. This has to be set once and stay # valid for all following months, otherwise only the names of the # long months might appear. # XXX: This might result in only the larger months' labels being # drawn. if graph_width < 30: continue # Add name. month = start_of_month.month name = MONTHS[month] month_name = QtGui.QGraphicsSimpleTextItem(name) rect = month_name.boundingRect() # XXX: The +2 at the end is just trial end error. I cannot figure # out a way to calculate it. The height of the rectangle is 16 # while the year subscale height is only 15. But the text is still # positioned too high without the +2. month_name.moveBy(((end_frac - start_frac) / 2 + start_frac) * self.width - \ rect.width() / 2, start_y + 2) month_name.start_frac = start_frac month_name.end_frac = end_frac self.month_labels.append(month_name) self.addToGroup(month_name)
# 2010-09 Tobi import matplotlib matplotlib.use("AGG") import subprocess from obspy.core import UTCDateTime, Stream, AttribDict from obspy.signal import coincidenceTrigger, cosTaper from obspy.seishub import Client NET = "BW" STATIONS = ("KW1", "KW2", "KW3") CHANNEL = "EHZ" # search from 2h before now to 1h before now T1 = UTCDateTime() - (60 * 60 * 2) T2 = T1 + (60 * 60 * 1) + 30 PAR = dict(LOW=10.0, # bandpass low corner HIGH=20.0, # bandpass high corner STA=0.5, # length of sta in seconds LTA=10, # length of lta in seconds ON=3.5, # trigger on threshold OFF=1, # trigger off threshold ALLOWANCE=1.2, # time in seconds to extend trigger-off time MAXLEN=10, # maximum trigger length in seconds MIN_STATIONS=3) # minimum of coinciding stations for alert PAR = AttribDict(PAR) SUMMARY = "/scratch/kw_trigger/kw_trigger.txt" PLOTDIR = "/scratch/kw_trigger/" MAILTO = ["megies"]
def dayScale(self, top=True): """ Creates the subdivisions of the month scale. """ color = self.color1 starttime = self.env.starttime endtime = self.env.endtime time_range = float(endtime - starttime) # Pixel counts. start_x = 0 end_x = self.width x_range = end_x - start_x # Top or bottom year scale. start_y = 30 end_y = 45 y_range = self.subscale_height # Get the number of days. starttime_day = UTCDateTime(starttime.year, starttime.month, starttime.day) endtime_day = UTCDateTime(endtime.year, endtime.month, endtime.day) days = int((endtime_day - starttime_day) / 86400) + 1 days_count = range(days) # Use the middle of the starting date to later calculate the current # day and account for leap seconds. noon_of_start = UTCDateTime(starttime.year, starttime.month, starttime.day, 12, 0, 0) # Only draw if there are less or equal than 150 days. if days > 150: return # Loop over every day. for day in days_count: today = noon_of_start + 86400 * day # Some variables. start_of_day = UTCDateTime(today.year, today.month, today.day, 0, 0, 0) end_of_day = start_of_day + 86400 # Calculate boundaries. start_frac = (start_of_day - starttime) / time_range if start_frac < 0: start_frac = 0 start = start_frac * x_range if start < 0: start = 0 start += start_x end_frac = (endtime - end_of_day) / time_range end_frac = 1.0 - end_frac if end_frac > 1.0: end_frac = 1.0 end = end_frac * x_range end = x_range - end if end > x_range: end = x_range end += start_x graph_width = (end_frac - start_frac) * x_range # Only draw every second box. if not day % 2: day_box = QtGui.QGraphicsRectItem(start, start_y, graph_width, y_range) day_box.start_frac = start_frac day_box.end_frac = end_frac day_box.setBrush(color) day_box.setZValue(-198) self.addToGroup(day_box) # Add to list for easier tracking. self.day_boxes.append(day_box) # If two narrow do not add a name. if graph_width < 20: continue # Add name. name = str(today.day) day_name = QtGui.QGraphicsSimpleTextItem(name) rect = day_name.boundingRect() # XXX: The +2 at the end is just trial end error. I cannot figure # out a way to calculate it. The height of the rectangle is 16 # while the year subscale height is only 15. But the text is still # positioned too high without the +2. day_name.moveBy(((end_frac - start_frac) / 2 + start_frac) * self.width - \ rect.width() / 2, start_y + 2) self.addToGroup(day_name) day_name.start_frac = start_frac day_name.end_frac = end_frac self.day_labels.append(day_name)