def create_result(self, scnl, origin_resource = None): ''' Write the psd data for the given scnl to file. ''' export_data = self.psd_data[scnl] first_time = UTCDateTime(sorted(export_data.keys())[0]) last_time = UTCDateTime(sorted(export_data.keys())[-1]) #last_key = sorted(export_data.iterkeys())[-1] #last_time = export_data[last_key]['end_time'] #first_time = sorted([x['start_time'] for x in export_data.values()])[0] #last_time = sorted([x['end_time'] for x in export_data.values()])[-1] shelve_result = result.ShelveResult(name = 'psd', start_time = first_time, end_time = last_time, origin_name = self.name, origin_resource = origin_resource, sub_directory = (scnl[0], scnl[1], "{0:04d}_{1:03d}".format(first_time.year, first_time.julday)), postfix = '_'.join(scnl), db = export_data) self.result_bag.add(shelve_result) self.logger.info("Published the result for scnl %s (%s to %s).", scnl, first_time.isoformat(), last_time.isoformat()) self.psd_data[scnl] = {}
def test_write_detection_to_database(self): ''' Test the writing to the database. ''' # Create a detection. # Set the date values. start_time = '2000-01-01T00:00:00' end_time = '2000-01-01T01:00:00' creation_time = UTCDateTime() # Get the stations from the inventory. inventory = self.project.db_inventory stat1 = inventory.get_station(name='DUBA')[0] stat2 = inventory.get_station(name='WADU')[0] stat3 = inventory.get_station(name='WAPE')[0] det = detection.Detection(start_time=start_time, end_time=end_time, creation_time=creation_time, stations=[stat1, stat2, stat3], max_pgv={ stat1.nsl_string: 0.1, stat2.nsl_string: 0.2, stat3.nsl_string: 0.3 }) det.write_to_database(self.project) detection_orm = self.project.db_tables['detection'] db_session = self.project.get_db_session() try: result = db_session.query(detection_orm).\ options(sqlalchemy.orm.subqueryload(detection_orm.stat1)).\ options(sqlalchemy.orm.subqueryload(detection_orm.stat2)).\ options(sqlalchemy.orm.subqueryload(detection_orm.stat3)).\ filter(detection_orm.id == det.db_id).all() finally: db_session.close() self.assertEqual(len(result), 1) tmp = result[0] self.assertEqual(tmp.start_time, UTCDateTime(start_time).timestamp) self.assertEqual(tmp.end_time, UTCDateTime(end_time).timestamp) self.assertEqual(tmp.creation_time, creation_time.isoformat()) self.assertEqual(tmp.stat1_id, stat1.id) self.assertEqual(tmp.stat2_id, stat2.id) self.assertEqual(tmp.stat3_id, stat3.id) self.assertEqual(tmp.stat1.id, stat1.id) self.assertEqual(tmp.stat2.id, stat2.id) self.assertEqual(tmp.stat3.id, stat3.id)
def test_write_to_database(self): ''' Test the write_to_database method. ''' creation_time = UTCDateTime() catalog = ev_core.Catalog(name='test', description='A test description.', agency_uri='uot', author_uri='tester', creation_time=creation_time) catalog.write_to_database(self.project) db_catalog_orm = self.project.dbTables['event_catalog'] db_session = self.project.getDbSession() result = db_session.query(db_catalog_orm).all() db_session.close() self.assertEqual(len(result), 1) tmp = result[0] self.assertEqual(tmp.name, 'test') self.assertEqual(tmp.description, 'A test description.') self.assertEqual(tmp.agency_uri, 'uot') self.assertEqual(tmp.author_uri, 'tester') self.assertEqual(tmp.creation_time, creation_time.isoformat())
def process(self, start_time, end_time, station_names, channel_names, event_catalog, event_ids=None): ''' Start the detection. Parameters ---------- start_time : :class:`~obspy.core.utcdatetime.UTCDateTime` The start time of the timespan for which to detect the events. end_time : :class:`~obspy.core.utcdatetime.UTCDateTime` The end time of the timespan for which to detect the events. station_names : list of Strings The names of the stations to process. channel_names : list of Strings The names of the channels to process. event_catalog : String The name of the event catalog to process. event_ids : List of Integer If individual events are specified, this list contains the database IDs of the events to process. ''' self.logger.info("Processing timespan %s to %s.", start_time.isoformat(), end_time.isoformat()) result_bag = ResultBag() event_lib = ev_core.Library('events') event_lib.load_catalog_from_db(self.project, name=event_catalog) catalog = event_lib.catalogs[event_catalog] if event_ids is None: # Load the events for the given time span from the database. # TODO: Remove the hardcoded min_event_length value and create # user-selectable filter fields. catalog.load_events(project=self.project, start_time=start_time, end_time=end_time, min_event_length=1) else: # Load the events with the given ids from the database. Ignore the # time-span. catalog.load_events(event_id=event_ids) # Abort the execution if no events are available for the time span. if not catalog.events: if event_ids is None: self.logger.info('No events found for the timespan %s to %s.', start_time.isoformat(), end_time.isoformat()) else: self.logger.info( 'No events found for the specified event IDs: %s.', event_ids) return # Get the channels to process. channels = [] for cur_station in station_names: for cur_channel in channel_names: channels.extend( self.project.geometry_inventory.get_channel( station=cur_station, name=cur_channel)) scnl = [x.scnl for x in channels] n_events = len(catalog.events) active_timespan = () try: for k, cur_event in enumerate(catalog.events): self.logger.info("Processing event %d (%d/%d).", cur_event.db_id, k, n_events) # Load the waveform data for the event and the given stations and # channels. # TODO: Add a feature which allows adding a window before and after # the event time limits. pre_event_time = 20 post_event_time = 10 # TODO: Make the length of the waveform load interval user # selectable. waveform_load_interval = 3600 # When many short events with small gaps inbetween are processed, # it is very ineffective to load the waveform for each event. Load # a larger time-span and then request the waveform data from the # waveclient stock. timespan_begin = UTCDateTime(cur_event.start_time.year, cur_event.start_time.month, cur_event.start_time.day, cur_event.start_time.hour) timespan_end = UTCDateTime( cur_event.end_time.year, cur_event.end_time.month, cur_event.end_time.day, cur_event.start_time.hour) + waveform_load_interval if not active_timespan: self.logger.info( "Initial stream request for hourly time-span: %s to %s.", timespan_begin.isoformat(), timespan_end.isoformat()) stream = self.request_stream(start_time=timespan_begin, end_time=timespan_end, scnl=scnl) active_timespan = (timespan_begin, timespan_end) cur_start_time = cur_event.start_time - pre_event_time cur_end_time = cur_event.end_time + post_event_time if not (((cur_start_time >= active_timespan[0]) and (cur_start_time <= active_timespan[1])) and ((cur_end_time >= active_timespan[0]) and (cur_end_time <= active_timespan[1]))): self.logger.info( "Requesting stream for hourly time-span: %s to %s.", timespan_begin.isoformat(), timespan_end.isoformat()) stream = self.request_stream(start_time=timespan_begin, end_time=timespan_end, scnl=scnl) active_timespan = (timespan_begin, timespan_end) stream = self.request_stream(start_time=cur_start_time, end_time=cur_end_time, scnl=scnl) # Execute the processing stack. # TODO: The 0.5 seconds where added because there's currently no # access to the event detection of the individual channels. Make # sure, that this hard-coded value is turned into a user-selectable # one or removed completely. process_limits = (cur_event.start_time - 0.5, cur_event.end_time) self.processing_stack.execute(stream=stream, process_limits=process_limits) # Put the results of the processing stack into the results bag. results = self.processing_stack.get_results() resource_id = self.project.rid + cur_event.rid result_bag.add(resource_id=resource_id, results=results) finally: # Add the time-span directory to the output directory. if k != len(catalog.events) - 1: cur_end_time = cur_event.end_time else: cur_end_time = end_time timespan_dir = start_time.strftime( '%Y%m%dT%H%M%S') + '_to_' + cur_end_time.strftime( '%Y%m%dT%H%M%S') cur_output_dir = os.path.join(self.output_dir, timespan_dir) # Save the processing results to files. result_bag.save(output_dir=cur_output_dir, scnl=scnl)
def read_gcmt_file(cmt_file): """We read the moment tensor information from a GCMT moment tensor file, and store its content in a python dictionary :param cmt_file: location of text file to be used :type cmt_file: string """ with open(cmt_file, 'r') as input_file: lines = [line.split() for line in input_file] if 'Q' in lines[0][0]: new_line = lines[0] code, year = lines[0][0].split('Q') lines[0] = [code, year] + new_line[1:] if 'W' in lines[0][0]: new_line = lines[0] code, year = lines[0][0].split('W') lines[0] = [code, year] + new_line[1:] year, month, day, hour, minute, second, lat, lon, hyp_depth\ = lines[0][1:10] year = int(year) month = int(month) day = int(day) hour = int(hour) minute = int(minute) second = int(float(second)) origin_time = UTCDateTime(year, month, day, hour, minute, second) date_time = origin_time.isoformat() time_shift = max(float(lines[2][2]), 5) half_duration = float(lines[3][2]) centroid_lat = float(lines[4][1]) centroid_lon = float(lines[5][1]) centroid_depth = float(lines[6][1]) mrr = float(lines[7][1]) mtt = float(lines[8][1]) mpp = float(lines[9][1]) mrt = float(lines[10][1]) mrp = float(lines[11][1]) mtp = float(lines[12][1]) input_dict = { 'mrr': mrr, 'mtt': mtt, 'mpp': mpp, 'mrt': mrt, 'mrp': mrp, 'mtp': mtp, 'datetime': date_time, 'date_origin': origin_time, 'lat': lat, 'lon': lon, 'depth': hyp_depth, 'time_shift': time_shift, 'half_duration': half_duration, 'centroid_lat': centroid_lat, 'centroid_lon': centroid_lon, 'centroid_depth': centroid_depth } return input_dict
def read_quake_file(quake_file): """We read the moment tensor information from a QuakeMl moment tensor file, and store its content in a python dictionary :param cmt_file: location of text file to be used :type cmt_file: string """ tree = ET.parse(quake_file) root = tree.getroot() tensor = next(elem for elem in root.iter() if 'momentTensor' in elem.tag) MRR = next(elem for elem in tensor.iter() if 'Mrr' in elem.tag) mrr = int(next(child.text for child in MRR)) * 10**7 MTT = next(elem for elem in tensor.iter() if 'Mtt' in elem.tag) mtt = int(next(child.text for child in MTT)) * 10**7 MPP = next(elem for elem in tensor.iter() if 'Mpp' in elem.tag) mpp = int(next(child.text for child in MPP)) * 10**7 MRT = next(elem for elem in tensor.iter() if 'Mrt' in elem.tag) mrt = int(next(child.text for child in MRT)) * 10**7 MRP = next(elem for elem in tensor.iter() if 'Mrp' in elem.tag) mrp = int(next(child.text for child in MRP)) * 10**7 MTP = next(elem for elem in tensor.iter() if 'Mtp' in elem.tag) mtp = int(next(child.text for child in MTP)) * 10**7 time_shift = next(elem.text for elem in tensor.iter() if 'riseTime' in elem.tag) M0 = next(elem for elem in tensor.iter() if 'scalarMoment' in elem.tag) m0 = float(next(child.text for child in M0)) * 10**7 half_duration = 1.2 * 10**-8 * m0**(1 / 3) origins = [elem for elem in root.iter() if 'origin' in elem.tag] first_origin = [] second_origin = [] for origin in origins: values = ['depthType' in elem.tag for elem in origin.iter()] if not any(values): first_origin = origin else: second_origin = origin Event_Lat = next(elem for elem in first_origin.iter() if 'latitude' in elem.tag) event_lat = float(next(child.text for child in Event_Lat)) Event_Lon = next(elem for elem in first_origin.iter() if 'longitude' in elem.tag) event_lon = float(next(child.text for child in Event_Lon)) Depth = next(elem for elem in first_origin.iter() if 'depth' in elem.tag) depth = float(next(child.text for child in Depth)) / 1000 Centroid_Lat = next(elem for elem in second_origin.iter() if 'latitude' in elem.tag) centroid_lat = float(next(child.text for child in Centroid_Lat)) Centroid_Lon = next(elem for elem in second_origin.iter() if 'longitude' in elem.tag) centroid_lon = float(next(child.text for child in Centroid_Lon)) Centroid_Depth = next(elem for elem in second_origin.iter() if 'depth' in elem.tag) centroid_depth = float(next(child.text for child in Centroid_Depth)) / 1000 Time = next(elem for elem in first_origin.iter() if 'time' in elem.tag) time = next(child.text for child in Time) origin_time = UTCDateTime(time) date_time = origin_time.isoformat() input_dict = { 'mrr': mrr, 'mtt': mtt, 'mpp': mpp, 'mrt': mrt, 'mrp': mrp, 'mtp': mtp, 'datetime': date_time, 'date_origin': origin_time, 'lat': event_lat, 'lon': event_lon, 'depth': depth, 'time_shift': time_shift, 'half_duration': half_duration, 'centroid_lat': centroid_lat, 'centroid_lon': centroid_lon, 'centroid_depth': centroid_depth } return input_dict