Python Client.get_events方法代码示例

# 需要导入模块: from obspy.fdsn import Client [as 别名]
# 或者: from obspy.fdsn.Client import get_events [as 别名]
def get_event_info(starttime, endtime, streams):
    events = []
    arrivals = {}
    try:
        client = FDSNClient("NERIES")
        events = client.get_events(starttime=starttime - 20 * 60,
                                   endtime=endtime)
        for ev in events[::-1]:
            has_arrivals = False
            origin = ev.origins[0]
            origin_time = origin.time
            lon1 = origin.longitude
            lat1 = origin.latitude
            depth = abs(origin.depth / 1e3)
            for st in streams:
                sta = st[0].stats.station
                lon2 = st[0].stats.coordinates['longitude']
                lat2 = st[0].stats.coordinates['latitude']
                dist = locations2degrees(lat1, lon1, lat2, lon2)
                tts = getTravelTimes(dist, depth)
                list_ = arrivals.setdefault(sta, [])
                for tt in tts:
                    tt['time'] = origin_time + tt['time']
                    if starttime < tt['time'] < endtime:
                        has_arrivals = True
                        list_.append(tt)
            if not has_arrivals:
                events[:] = events[:-1]
    except Exception as e:
        msg = ("Problem while fetching events or determining theoretical "
               "phases: %s: %s" % (e.__class__.__name__, str(e)))
        return None, None, msg
    return events, arrivals, None

# 需要导入模块: from obspy.fdsn import Client [as 别名]
# 或者: from obspy.fdsn.Client import get_events [as 别名]
def get_events():
    try:
        return readEvents(evname)
    except:
        pass
    client = Client()
    events = client.get_events(starttime=t1, endtime=t2, latitude=lat,
                               longitude=lon, minradius=20, maxradius=100,
                               minmagnitude=6.)
    events.write(evname, 'QUAKEML')
    return events

# 需要导入模块: from obspy.fdsn import Client [as 别名]
# 或者: from obspy.fdsn.Client import get_events [as 别名]
def get_events():
    print('Read event file')
    try:
        return readEvents(evname)
    except:
        pass
    client = FSDNClient('NERIES')
    events = client.get_events(**event_kwargs)
    events.events.sort(key=lambda e: e.origins[0].time)
    events.write(evname, 'QUAKEML')
    return events

# 需要导入模块: from obspy.fdsn import Client [as 别名]
# 或者: from obspy.fdsn.Client import get_events [as 别名]
def test_gmt_catalog():
    (options, args, parser) = command_parse()
    input_dics = read_input_command(parser)
    # Changing the input_dics values for testing
    input_dics['min_date'] = UTCDateTime('2011-03-01')
    input_dics['max_date'] = UTCDateTime('2011-03-20')
    input_dics['min_mag'] = 8.9

    evlatmin = input_dics['evlatmin']
    evlatmax = input_dics['evlatmax']
    evlonmin = input_dics['evlonmin']
    evlonmax = input_dics['evlonmax']

    evlat = input_dics['evlat']
    evlon = input_dics['evlon']
    evradmax = input_dics['evradmax']
    evradmin = input_dics['evradmin']

    client_fdsn = Client_fdsn(base_url=input_dics['event_catalog'])
    events_QML = client_fdsn.get_events(
        minlatitude=evlatmin,
        maxlatitude=evlatmax,
        minlongitude=evlonmin,
        maxlongitude=evlonmax,
        latitude=evlat,
        longitude=evlon,
        maxradius=evradmax,
        minradius=evradmin,
        mindepth=input_dics['min_depth'],
        maxdepth=input_dics['max_depth'],
        starttime=input_dics['min_date'],
        endtime=input_dics['max_date'],
        minmagnitude=input_dics['min_mag'],
        maxmagnitude=input_dics['max_mag'],
        orderby='time',
        catalog=None,
        magnitudetype=input_dics['mag_type'])

    assert events_QML[0].preferred_origin().latitude == 38.2963
    assert events_QML[0].preferred_origin().longitude == 142.498
    assert events_QML[0].preferred_origin().depth == 19700.0

# 需要导入模块: from obspy.fdsn import Client [as 别名]
# 或者: from obspy.fdsn.Client import get_events [as 别名]
def get_cat(data_center = None, **kwargs):
    '''
    Function to get catalog data from different data center
    data_center - specify the data center i.e. 'IRIS'
    Other arguments you can use:
    :type starttime: :class:`~obspy.core.utcdatetime.UTCDateTime`, optional
        :param starttime: Limit to events on or after the specified start time.
        :type endtime: :class:`~obspy.core.utcdatetime.UTCDateTime`, optional
        :param endtime: Limit to events on or before the specified end time.
        :type minlatitude: float, optional
        :param minlatitude: Limit to events with a latitude larger than the
            specified minimum.
        :type maxlatitude: float, optional
        :param maxlatitude: Limit to events with a latitude smaller than the
            specified maximum.
        :type minlongitude: float, optional
        :param minlongitude: Limit to events with a longitude larger than the
            specified minimum.
        :type maxlongitude: float, optional
        :param maxlongitude: Limit to events with a longitude smaller than the
            specified maximum.
        :type latitude: float, optional
        :param latitude: Specify the latitude to be used for a radius search.
        :type longitude: float, optional
        :param longitude: Specify the longitude to the used for a radius
            search.
        :type minradius: float, optional
        :param minradius: Limit to events within the specified minimum number
            of degrees from the geographic point defined by the latitude and
            longitude parameters.
        :type maxradius: float, optional
        :param maxradius: Limit to events within the specified maximum number
            of degrees from the geographic point defined by the latitude and
            longitude parameters.
        :type mindepth: float, optional
        :param mindepth: Limit to events with depth more than the specified
            minimum.
        :type maxdepth: float, optional
        :param maxdepth: Limit to events with depth less than the specified
            maximum.
        :type minmagnitude: float, optional
        :param minmagnitude: Limit to events with a magnitude larger than the
            specified minimum.
        :type maxmagnitude: float, optional
        :param maxmagnitude: Limit to events with a magnitude smaller than the
            specified maximum.
        :type magnitudetype: str, optional
        :param magnitudetype: Specify a magnitude type to use for testing the
            minimum and maximum limits.
        :type includeallorigins: bool, optional
        :param includeallorigins: Specify if all origins for the event should
            be included, default is data center dependent but is suggested to
            be the preferred origin only.
        :type includeallmagnitudes: bool, optional
        :param includeallmagnitudes: Specify if all magnitudes for the event
            should be included, default is data center dependent but is
            suggested to be the preferred magnitude only.
        :type includearrivals: bool, optional
        :param includearrivals: Specify if phase arrivals should be included.
        :type eventid: str or int (dependent on data center), optional
        :param eventid: Select a specific event by ID; event identifiers are
            data center specific.
        :type limit: int, optional
        :param limit: Limit the results to the specified number of events.
        :type offset: int, optional
        :param offset: Return results starting at the event count specified,
            starting at 1.
        :type orderby: str, optional
        :param orderby: Order the result by time or magnitude with the
            following possibilities:
                * time: order by origin descending time
                * time-asc: order by origin ascending time
                * magnitude: order by descending magnitude
                * magnitude-asc: order by ascending magnitude
        :type catalog: str, optional
        :param catalog: Limit to events from a specified catalog
        :type contributor: str, optional
        :param contributor: Limit to events contributed by a specified
            contributor.
        :type updatedafter: :class:`~obspy.core.utcdatetime.UTCDateTime`,
            optional
        :param updatedafter: Limit to events updated after the specified time.
        :type filename: str or open file-like object
        :param filename: If given, the downloaded data will be saved there
            instead of being parse to an ObsPy object. Thus it will contain the
            raw data from the webservices.
    
    '''
    #get the catalog
    if data_center is None:
        data_center = 'USGS'
        
    client = Client(data_center)
    sio = StringIO()
    #save the catalog into a StringIO object
    cat = client.get_events(filename=sio, **kwargs)
    
    #specify the entries you want to replace with (the inconsistent ones) in the following dictionary
    rep = {"quarry_blast": "quarry blast", "quarry": "quarry blast", "quarry blast_blast":"quarry blast" }
    
#.........这里部分代码省略.........

# 需要导入模块: from obspy.fdsn import Client [as 别名]
# 或者: from obspy.fdsn.Client import get_events [as 别名]
    def test_download_urls_for_custom_mapping(self, download_url_mock):
        """
        Tests the downloading of data with custom mappings.
        """
        base_url = "http://example.com"

        # More extensive mock setup simulation service discovery.
        def custom_side_effects(*args, **kwargs):
            if "version" in args[0]:
                return 200, "1.0.200"
            elif "event" in args[0]:
                with open(os.path.join(
                        self.datapath, "2014-01-07_iris_event.wadl"),
                        "rb") as fh:
                    return 200, fh.read()
            elif "station" in args[0]:
                with open(os.path.join(
                        self.datapath,
                        "2014-01-07_iris_station.wadl"), "rb") as fh:
                    return 200, fh.read()
            elif "dataselect" in args[0]:
                with open(os.path.join(
                        self.datapath,
                        "2014-01-07_iris_dataselect.wadl"), "rb") as fh:
                    return 200, fh.read()
            return 404, None

        download_url_mock.side_effect = custom_side_effects

        # Some custom urls
        base_url_event = "http://other_url.com/beta/event_service/11"
        base_url_station = "http://some_url.com/beta2/station/7"
        base_url_ds = "http://new.com/beta3/dataselect/8"

        # An exception will be raised if not actual WADLs are returned.
        # Catch warnings to avoid them being raised for the tests.
        with warnings.catch_warnings(record=True) as w:
            warnings.simplefilter("always")
            c = Client(base_url=base_url, service_mappings={
                "event": base_url_event,
                "station": base_url_station,
                "dataselect": base_url_ds,
            })
        for warning in w:
            self.assertTrue("Could not parse" in str(warning) or
                            "cannot deal with" in str(warning))

        # Test the dataselect downloading.
        download_url_mock.reset_mock()
        download_url_mock.side_effect = None
        download_url_mock.return_value = 404, None
        try:
            c.get_waveforms("A", "B", "C", "D", UTCDateTime() - 100,
                            UTCDateTime())
        except:
            pass
        self.assertTrue(
            base_url_ds in download_url_mock.call_args_list[0][0][0])

        # Test the station downloading.
        download_url_mock.reset_mock()
        download_url_mock.side_effect = None
        download_url_mock.return_value = 404, None
        try:
            c.get_stations()
        except:
            pass
        self.assertTrue(
            base_url_station in download_url_mock.call_args_list[0][0][0])

        # Test the event downloading.
        download_url_mock.reset_mock()
        download_url_mock.side_effect = None
        download_url_mock.return_value = 404, None
        try:
            c.get_events()
        except:
            pass
        self.assertTrue(
            base_url_event in download_url_mock.call_args_list[0][0][0])

# 需要导入模块: from obspy.fdsn import Client [as 别名]
# 或者: from obspy.fdsn.Client import get_events [as 别名]
#minmag=0.0
#maxmag=4.0

#tmin=UTCDateTime("2013-11-01 00:00:00")
#tmin=UTCDateTime(iyear+"-"+imm+"-"+idd+" "+ihh+":"+imi+":"+ise)
#print tmin

#tmax=UTCDateTime("2013-12-01 00:00:00")
#tmax=UTCDateTime(fyear+"-"+fmm+"-"+fdd+" "+fhh+":"+fmi+":"+fse)
#print tmax

catalog=fdsn.get_events(starttime=tmin,
			endtime=tmax,
			includearrivals=True,
			minmagnitude=mmin,
			maxmagnitude=mmax,
			latitude=lat,
			longitude=lon,
			minradius=rmin,
			maxradius=rmax)

#catalog=fdsn.get_events(starttime=t0, endtime=t1, includearrivals=True,
#			includepicks=True, format="catalog")

#print catalog.__str__(print_all=True)

#cat2=catalog.filter("magnitude <= minmag")
#print cat2.__str__(print_all=True)

f=open("evlist.txt","w")
for event in catalog:

# 需要导入模块: from obspy.fdsn import Client [as 别名]
# 或者: from obspy.fdsn.Client import get_events [as 别名]
        os.makedirs(path)
        return True
    else:
        print path + ' exists'
        return False

if __name__ == '__main__':
    client = Client("IRIS")
    network = "XF"
    starttime = UTCDateTime("2003-06-01")
    endtime = UTCDateTime("2003-11-01")
    # endtime = UTCDateTime("1999-05-19")
    # endtime = UTCDateTime("1998-12-04")
    # endtime = UTCDateTime("1998-12-05")    

    events = client.get_events(starttime=starttime, endtime=endtime,
                               minmagnitude=5.5, catalog="ISC")
    # events.plot()

    stations = client.get_stations(network=network, station="H*",
                                   starttime=starttime, endtime=endtime,
                                   level="response")
    # stations.plot()
    # stations.plot(projection=u'local', resolution=u'f')
    default_dir = os.getcwd() + '/data_60_120/'
    for event in events:
        origin = event.origins[0]
        print origin
        event_latitude = origin.latitude
        event_longitude = origin.longitude
        event_depth = origin.depth  # km
        event_time = origin.time

# 需要导入模块: from obspy.fdsn import Client [as 别名]
# 或者: from obspy.fdsn.Client import get_events [as 别名]
def get_quakes(startcoors,endcoors,minmag=5.0):
    '''Get earthquakes within a region around the start and end coordinates. These will be plotted on the section, with x distance'''

    client = Client('USGS')

    #Only get intermediate depth quakes, or deeper
    mindepth = 60
    boxHW = 0.5

    quakefile = open('quakedata.dat','w')

    startlon = startcoors[0] - boxHW
    startlat = startcoors[1] + boxHW

    endlon = endcoors[0] + boxHW
    endlat = endcoors[1] - boxHW

    minlon = min(startlon,endlon)
    maxlon = max(startlon,endlon)

    minlat = min(startlat,endlat)
    maxlat = max(startlat,endlat)

    starttime = '1970-01-01'
    endtime = str(datetime.datetime.today()).split(' ')[0]
    
    #print startcoors,endcoors
    
    #print minlon,minlat,maxlon,maxlat

    print '---------------------\nUsing Obspy to get quakes\n---------------------'

    quakecat = client.get_events(starttime=UTCDateTime(starttime), endtime=UTCDateTime(endtime), minlongitude=minlon, maxlongitude=maxlon, minlatitude=minlat, maxlatitude=maxlat, minmagnitude=minmag,mindepth=mindepth)
    
    #Get the moment tensors for these events, if they exist
    #Currenlty not working 
    #quakes,mts = cat2list(quakecat)
    #focmecs = [row[4:] for row in mts]

    for event in quakecat:

        evlon = event.origins[0].longitude
        evlat = event.origins[0].latitude
        evdep = event.origins[0].depth

        quakefile.write('%s %s %s\n' %(evlon,evlat,evdep))

    quakefile.close()

    #Work out the distance from each quake to the profile line, and write to a file 
    #Create the section coordinates. Should make some sort of auto-decision about the spacing
    sectionname = 'tmp_toposection.dat'

    print '---------------------\nMaking section through topography\n---------------------'

    os.system('gmt project -C%g/%g -E%g/%g -G10 -Q > %s' %(minlon,minlat,maxlon,maxlat,sectionname))
    os.system('gmt grdtrack %s -G%s > gridsectiontopo.dat' %(sectionname,topofile))

    #Open the topo file and extract the longest distance. This will be used to scale the quake locations

    infile = open('gridsectiontopo.dat','r')
    lines = infile.readlines()
    infile.close()

    topoX = []
    topoY = []

    for line in lines:
        vals = line.split()
        topoX.append(float(vals[2]))
        topoY.append(float(vals[3]))

    maxdist = topoX[-1]
    topoX = np.array(topoX)
    topoY = np.array(topoY)

    print '---------------------\nGetting quake distances\n---------------------'

    #Make a file containing quakelon, quakelat, dist, and dist along profile
    os.system('gmt mapproject quakedata.dat -Lgridsectiontopo.dat/k > quake_dist.dat')

    #Reorder the columns and do another grdtrack to get distance along the profile
    os.system("awk '{print $5,$6,$1,$2,$3,$4}' quake_dist.dat > quaketmp.dat")
    os.system("rm quake_dist.dat")

    #Now, calculate distance along the profile from the start point
    os.system('gmt mapproject quaketmp.dat -G%g/%g/k > quake_points.dat' %(minlon,minlat))
    os.system('rm quaketmp.dat')

    #Now, open the newly created file and grid section file, and pull the distance data
    infile1 = open('quake_points.dat','r')
    lines1 = infile1.readlines()
    infile1.close()

    Xdistances_quakes = []
    Ydepths_quakes = []

    for line in lines1:
        vals = line.split(' ')
        try:
#.........这里部分代码省略.........

# 需要导入模块: from obspy.fdsn import Client [as 别名]
# 或者: from obspy.fdsn.Client import get_events [as 别名]
# enter the information for catalogue 1 search
minlat, maxlat, minlon, maxlon = (-40.0, -12.5, 113.0, 154.0) 

event_list = []

for c in client_list:
    print "Processing events from the {} catalogue ... \n".format(c)


    try:
        client = Client(c)

        catalogue = client.get_events(starttime=t1, endtime=t2,
                                           minlatitude=minlat,
                                           maxlatitude=maxlat,
                                           minlongitude=minlon, 
                                           maxlongitude=maxlon)

            
        for i in catalogue:
            event_list.append(i)
            
    except Exception as error: 
        print error
        

print event_list
 
 

# 需要导入模块: from obspy.fdsn import Client [as 别名]
# 或者: from obspy.fdsn.Client import get_events [as 别名]
#convert start date from datetime object to a UTCDateTime object
start = UTCDateTime(date_start)

# set minimum magnitude threshold to search for.
min_mag = 2.0

minlat = -39.1 #minlatitude
maxlat = -37.0 # maxlatitude 
minlon = 143.5 #minlongitude 
maxlon = 147.0 #maxlongitude 

cat = client.get_events(starttime=date_start, 
                        endtime=date_end, 
                        minlatitude=minlat,
                        maxlatitude=maxlat,
                        minlongitude=minlon,
                        maxlongitude=maxlon,
                        minmagnitude=min_mag)

#print(cat)

cat.plot()
print(cat.__str__(print_all=True))

net = 'AU' 

stat = 'TOO'

date_start = UTCDateTime("2003-10-18T10:29:26.580000Z")

# 需要导入模块: from obspy.fdsn import Client [as 别名]
# 或者: from obspy.fdsn.Client import get_events [as 别名]
from obspy.core.event import readEvents

fdsn=Client(base_url="http://datasisint.unb.br:8080")

tmin = UTCDateTime("2015-324")
tmax = UTCDateTime("2015-325")
mmin=1
mmax=9
rmin=3
rmax=10
lat=-11.6
lon=-56.7

#print str(tmin)+" "+str(tmax)+" "+str(mmin)+" "+str(mmax)+" "+str(rmin)+" "+str(rmax)+" "+str(lat)+" "+str(lon)

catalog=fdsn.get_events(starttime=tmin, endtime=tmax)

#, includearrivals=True, minmagnitude=str(mmin), maxmagnitude=str(mmax), latitude=str(lat), longitude=str(lon), minradius=str(rmin), maxradius=str(rmax))

for event in catalog:
        evpref=event.preferred_origin()
	author=evpref.creation_info.author
        #evid=evpref.resource_id
        evid=event.resource_id.id.replace("smi:scs/0.6/","")
        evtype=str(event.event_type).replace(" ","-")
	 

        print str(evid)+" "+author+" "+evtype
#print catalog