2.1. Template creation — EQcorrscan 0.1.0 documentation

# 2.1. Template creation

In this example we will download some data and picks from the New Zealand GeoNet database and make use of the functions in EQcorrscan to quickly and simply generate templates for use in matched-filter detection. In the example we are looking at an earthquake sequence on the east coast of New Zealand’s North Island that occurred on the 4th of January 2016. We will take a set of four template events from the sequence that have been picked by GeoNet, of a range of magnitudes. You can decide if these were good templates or not. You could easily extend this by choosing more template events (the mainshock in the sequence is a M 5 and you can get the information by clicking here).

You do not need to use data from an online server, many pick formats can be parsed, either by obspy, or (for seisan pick files) through the Sfile_utils module in EQcorrscan.

This template script is written to be general, so you should be able to give command line arguments to the script to generate templates from other FDSN databases. Note that some data-centers do not support full FDSN quakeml files, and working out which do is quite painful.

Try this example for another, Northern California Data Center earthquake:

`python template_creation.py NCEDC 72572665`

This will (unfortunately for you) generate a warning about un-labelled picks, as many data-centers do not provide phase-hints with their picks. We care about which phase is which when we have to run our cross-correlation re-picker (yet to be completed), which means that we, by convention, assign P-picks to the vertical channel and S-picks to both horizontal channels.

Note: To run this script and for all map plotting you will need to install matplotlib-toolkits basemap package. Install instructions and a link to the download are here.

    """
    Simple tutorial detailing how to generate a series of templates from catalog\
    data available online.
    """

    def mktemplates(network_code='GEONET',
                    publicIDs=['2016p008122', '2016p008353', '2016p008155',
                               '2016p008194']):
        """Functional wrapper to make templates"""

        from collections import Counter
        from eqcorrscan.core import template_gen

        # This import section copes with namespace changes between obspy versions
        import obspy
        if int(obspy.__version__.split('.')[0]) >= 1:
            from obspy.clients.fdsn import Client
            from obspy import read_events
        else:
            from obspy.fdsn import Client
            from obspy import readEvents as read_events
        from obspy.core.event import Catalog

        # We want to download some QuakeML files from the New Zealand GeoNet
        # network, GeoNet currently doesn't support FDSN event queries, so we
        # have to work around to download quakeml from their quakeml.geonet site.

        client = Client(network_code)
        # We want to download a few events from an earthquake sequence, these are
        # identified by publiID numbers, given as arguments

        catalog = Catalog()
        for publicID in publicIDs:
            if network_code == 'GEONET':
                data_stream = client._download('http://quakeml.geonet.org.nz/' +
                                               'quakeml/1.2/' + publicID)
                data_stream.seek(0, 0)
                catalog += read_events(data_stream, format="quakeml")
                data_stream.close()
            else:
                catalog += client.get_events(eventid=publicID,
                                             includearrivals=True)

        # Lets plot the catalog to see what we have
        catalog.plot(projection='local', resolution='h')

        # We don't need all the picks, lets take the information from the
        # five most used stations
        all_picks = []
        for event in catalog:
            all_picks += [(pick.waveform_id.station_code,
                           pick.waveform_id.channel_code) for pick in event.picks]
        all_picks = Counter(all_picks).most_common(5)
        all_picks = [pick[0] for pick in all_picks]

        for event in catalog:
            if len(event.picks) == 0:
                raise IOError('No picks found')
            event.picks = [pick for pick in event.picks
                           if (pick.waveform_id.station_code,
                               pick.waveform_id.channel_code) in all_picks]

        # Now we can generate the templates
        templates = template_gen.from_client(catalog=catalog,
                                             client_id=network_code,
                                             lowcut=2.0, highcut=9.0,
                                             samp_rate=20.0, filt_order=4,
                                             length=3.0, prepick=0.05,
                                             swin='all', debug=1, plot=True)

        # We now have a series of templates! Using Obspys Stream.write() method we
        # can save these to disk for later use.  We will do that now for use in the
        # following tutorials.
        for i, template in enumerate(templates):
            template.write('tutorial_template_' + str(i) + '.ms', format='MSEED')
            # Note that this will warn you about data types.  As we don't care
            # at the moment, whatever obspy chooses is fine.
        return

    if __name__ == '__main__':
        """Wrapper for template creation"""
        import sys
        import warnings
        if not len(sys.argv) > 1:
            warnings.warn('Needs a network ID followed by a list of event IDs, ' +
                          'will run the test case instead')
            mktemplates()
        else:
            net_code = sys.argv[1]
            idlist = list(sys.argv)[2:]
            print(idlist)
            mktemplates(net_code, idlist)