def db2stream(dbname, orid, t_pre=T_PRE, t_post=T_POST): """ Return obspy.Stream of waveforms around p-arrival for a given orid """ DBPROCESS_CMDS = ('process', [('dbopen assoc', 'dbjoin -o arrival', 'dbsubset orid=={0}'.format(orid), 'dbsubset iphase=~/P.*/', 'dbjoin wfdisc sta chan', 'dbsubset arrival.time <= wfdisc.endtime && arrival.time >= wfdisc.time', 'dbgroup sta chan time delta dir dfile', 'dbsort -r delta', )]) st = obspy.core.Stream() dbpath = os.path.abspath(os.path.dirname(dbname)) with dbapi2.connect(dbname) as conn: curs = conn.cursor(CONVERT_NULL=True, row_factory=OrderedDictRow) nrecs = curs.execute(*DBPROCESS_CMDS) LOG.debug('Number of picks/waveforms: {0}'.format(nrecs)) for c in curs: fpath = os.path.join(dbpath, c['dir'], c['dfile']) t0 = obspy.core.UTCDateTime(c['time']-t_pre) t1 = obspy.core.UTCDateTime(c['time']+t_post) _st = obspy.core.read(fpath, starttime=t0, endtime=t1) if len(_st) > 1: _st.merge() st += _st return st
def __init__(self, database, perm='r', **kwargs): """ Initialize converter and connect to database Inputs ====== database : str name of database **kwargs : extra keyword args kwargs ------ perm : str of permissions ('r') pf : str name of pf file containing settings ('db2quakeml') """ # Load config using Antelope-style param file if 'pf' in kwargs: _pf = kwargs.pop('pf') else: _pf = 'db2quakeml' self.load_pf(_pf) super(AntelopeToEventConverter, self).__init__(**kwargs) self.connection = connect(database, perm, row_factory=OrderedDictRow) self.connection.CONVERT_NULL = True
def get_nearest_event_description(self, latitude, longitude, database=None): """ Get the nearest place to a lat/lon from a db with a 'places' table Inputs ------ database : str of database with 'places' table latitude : float of latitude longitude : float of longitude Returns : string of the distance and compass azimuth to a place """ if database is None: database = self.place_db try: curs = connect(database).cursor(row_factory=OrderedDictRow) nrecs = curs.execute.lookup(table='places') stats = array([gps2DistAzimuth(latitude, longitude, r['lat'], r['lon']) for r in curs]) ind = stats.argmin(0)[0] minstats = stats[ind] curs.scroll(int(ind), 'absolute') minrec = curs.fetchone() dist, azi, backazi = minstats compass = azimuth2compass(backazi) place_info = {'distance': dist/1000., 'direction': compass, 'city': minrec['place'], 'state': minrec['state']} curs.close() s = "{distance:0.1f} km {direction} of {city}, {state}".format(**place_info) return self._nearest_cities_description(s) except: return None
def get_event(self, dsn, orid=None, evid=None, origin=True, magnitude=True, pick=False, focal_mechanism=False, anss=False): # pylint: disable=unused-argument, too-many-arguments """ Run conversion with config """ # IF REGULAR EVENT, USE DATABASE ####################################################################### # Make db Connection -- wrap in context # with connect(dsn, row_factory=OrderedDictRow, # CONVERT_NULL=True) as conn: with connect(dsn) as conn: db = DatabaseConverter(conn, self._conv) event = db.extract_origin(orid, origin=origin, magnitude=magnitude, pick=pick, focal_mechanism=focal_mechanism, anss=anss) # Set preferreds. The extract method should return in reversed time # order, so always choosing the first origin, mag, should be an OK # default. Need to use an algorithm for a preferred mag type. For # focalmechs, should be mt solutions in reversed time order, then # first motions in reveresed time order. This means that a default # would be any latest MT, then any latest FM. Or writecustom algorithm. try: event['preferredOriginID'] = event['origin'][0]['@publicID'] event['preferredMagnitudeID'] = qml.find_preferred_mag( event['magnitude'][::-1], self.preferred_magtypes) if event.get('focalMechanism'): event['preferredFocalMechanismID'] = \ event['focalMechanism'][0]['@publicID'] except Exception as ex: self.logger.exception(ex) # # Try the nearest places thing... # if self.placesdb and os.path.exists(self.placesdb): try: orig = event['origin'][0] ncd = get_nearest_place( self.placesdb, (orig['longitude']['value'], orig['latitude']['value'])) event['description'] = self._conv.description(ncd) except Exception as ex: self.logger.exception(ex) return event
def test_connection_context(self): """Test for Connection context manager methods""" with connect(self.dsn) as conn: dbptr = Dbptr(getattr(conn, '_dbptr')) self.assertNotEqual( dbptr.query('dbDATABASE_COUNT'), 0 ) self.assertEqual( dbptr.query('dbDATABASE_COUNT'), 0 )
def get_nearest_place(dsn, coords): # pylint: disable=too-many-locals """ Return dict of QML nearest_cities given a data source and coordinates dsn : str of (database name of places12 schema for now) coords : tuple of (x, y) Relies on Antelope procedure calls... """ compass = ('N', 'NNE', 'NE', 'ENE', 'E', 'ESE', 'SE', 'SSE', 'S', 'SSW', 'SW', 'WSW', 'W', 'WNW', 'NW', 'NNW') wedge = 360. / len(compass) with connect(dsn, row_factory=OrderedDictRow, CONVERT_NULL=True) as conn: coord = {'elat': coords[1], 'elon': coords[0]} curs = conn.cursor() curs.execute.lookup(table='places') cmd = "deg2km(distance({elat}, {elon}, lat, lon))" distances = [ curs.execute.ex_eval(cmd.format(**coord)) for curs._record in range(curs.rowcount) ] cmd = "azimuth(lat, lon, {elat}, {elon})" backazis = [ curs.execute.ex_eval(cmd.format(**coord)) for curs._record in range(curs.rowcount) ] # Find the record with the min distance ind = min(xrange(len(distances)), key=distances.__getitem__) dist = distances[ind] backazi = backazis[ind] curs.scroll(int(ind), 'absolute') minrec = curs.fetchone() shift_azi = (backazi + wedge / 2) - (360 * (int(backazi + wedge / 2) / 360)) needle = compass[int(math.floor(shift_azi / wedge))] place_info = { 'distance': dist, 'direction': needle, 'city': minrec['place'], 'state': minrec['state'] } string = "{distance:0.1f} km {direction} of {city}, {state}".format( **place_info) return string
def get_deleted_event(self, dsn, orid=None, evid=None, anss=False): """ Return a stub event set to "not existing" Notes ----- Maybe not the place for this method, but best place for now """ try: with connect(dsn) as conn: db = DatabaseConverter(conn, self._conv) event = db.get_event(orid=orid, evid=evid, anss=anss) if event is None: raise ValueError("Event not found") except DbprocessError: event = self._conv.map_event({'evid': evid}, anss=anss) finally: event['type'] = "not existing" return event
def setUp(self): self.dsn = '/opt/antelope/data/db/demo/demo' self.NRECS_ORIGIN = 1351 self.conn = connect(self.dsn) self.curs = self.conn.cursor()
def test_connection_cursor(self): """Test for Connection cursor function""" with connect(self.dsn) as conn: self.assertIsInstance( conn.cursor(), Cursor )
def test_connect(self): """Test for connect function""" conn = connect(self.dsn) self.assertIsInstance(conn, Connection) conn.close()