def test_arias():
    ddir = os.path.join('data', 'testdata')
    datadir = pkg_resources.resource_filename('gmprocess', ddir)
    data_file = os.path.join(datadir, 'arias_data.json')
    with open(data_file, 'rt') as f:
        jdict = json.load(f)

    time = np.array(jdict['time'])
    # input output is m/s/s
    acc = np.array(jdict['acc']) / 100
    target_IA = jdict['ia']
    delta = time[2] - time[1]
    sr = 1 / delta
    header = {
        'delta': delta,
        'sampling_rate': sr,
        'npts': len(acc),
        'units': 'm/s/s',
        'channel': 'HN1',
        'standard': {'corner_frequency': np.nan,
            'station_name': '',
            'source': 'json',
            'source_file': '',
            'instrument': '',
            'instrument_period': np.nan,
            'source_format': 'json',
            'comments': '',
            'structure_type': '',
            'sensor_serial_number': '',
            'process_level': 'raw counts',
            'process_time': '',
            'horizontal_orientation': np.nan,
            'units': 'acc',
            'instrument_damping': np.nan}
    }
    # input is cm/s/s output is m/s/s
    trace = StationTrace(data=acc * 100, header=header)
    trace2 = trace.copy()
    trace2.stats.channel = 'HN2'
    stream = StationStream([trace, trace2])
    station = StationSummary.from_stream(stream, ['ARITHMETIC_MEAN'], ['arias'])
    pgms = station.pgms
    Ia = pgms[(pgms.IMT == 'ARIAS') & (pgms.IMC == 'ARITHMETIC_MEAN')].Result.tolist()[0]
    # the target has only one decimal place and is in cm/s/s
    Ia = Ia * 100
    np.testing.assert_almost_equal(Ia, target_IA, decimal=1)

    # Test other components
    data_files, _ = read_data_dir('cwb', 'us1000chhc', '2-ECU.dat')
    stream = read_data(data_files[0])[0]
    station = StationSummary.from_stream(stream,
                                         ['channels', 'gmrotd', 'rotd50',
                                             'greater_of_two_horizontals', 'ARITHMETIC_MEAN'],
                                         ['arias'])
    stream = StationSummary.from_stream(stream, ['gmrotd50'], ['arias'])
    assert stream.pgms.Result.tolist() == []
def test_exceptions():
    datafiles, _ = read_data_dir(
        'geonet', 'us1000778i', '20161113_110259_WTMC_20.V2A')
    datafile_v2 = datafiles[0]
    stream_v2 = read_geonet(datafile_v2)[0]
    stream1 = stream_v2.select(channel="HN1")
    pgms = StationSummary.from_stream(stream1, ['gmrotd50'], ['pga']).pgms
    assert np.isnan(pgms.Result.iloc[0])

    for trace in stream_v2:
        stream1.append(trace)
    pgms = StationSummary.from_stream(stream1, ['gmrotd50'], ['pga']).pgms
    assert np.isnan(pgms.Result.iloc[0])
def test_metrics():
    eventid = 'usb000syza'
    datafiles, event = read_data_dir('knet',
                                     eventid,
                                     '*')
    datadir = os.path.split(datafiles[0])[0]
    raw_streams = StreamCollection.from_directory(datadir)
    config = get_config()
    # turn off sta/lta check and snr checks
    newconfig = drop_processing(config, ['check_sta_lta', 'compute_snr'])
    processed_streams = process_streams(raw_streams, event, config=newconfig)

    tdir = tempfile.mkdtemp()
    try:
        tfile = os.path.join(tdir, 'test.hdf')
        workspace = StreamWorkspace(tfile)
        workspace.addEvent(event)
        workspace.addStreams(event, processed_streams, label='processed')
        stream1 = processed_streams[0]
        stream2 = processed_streams[1]
        summary1 = StationSummary.from_config(stream1)
        summary2 = StationSummary.from_config(stream2)
        workspace.setStreamMetrics(event.id, 'processed', summary1)
        workspace.setStreamMetrics(event.id, 'processed', summary2)
        summary1_a = workspace.getStreamMetrics(event.id,
                                                stream1[0].stats.station,
                                                'processed')
        s1_df_in = summary1.pgms.sort_values(['IMT', 'IMC'])
        s1_df_out = summary1_a.pgms.sort_values(['IMT', 'IMC'])
        array1 = s1_df_in['Result'].as_matrix()
        array2 = s1_df_out['Result'].as_matrix()
        np.testing.assert_almost_equal(array1, array2, decimal=4)

        df = workspace.getMetricsTable(event.id)
        cmp_series = {'GREATER_OF_TWO_HORIZONTALS': 0.6787,
                      'HN1': 0.3869,
                      'HN2': 0.6787,
                      'HNZ': 0.7663}
        pga_dict = df.iloc[0]['PGA'].to_dict()
        for key, value in pga_dict.items():
            value2 = cmp_series[key]
            np.testing.assert_almost_equal(value, value2, decimal=4)

        workspace.close()
    except Exception as e:
        raise(e)
    finally:
        shutil.rmtree(tdir)
    def calcStreamMetrics(self, eventid, stations=None,
                          labels=None, imclist=None, imtlist=None):
        """Create station metrics for specified event/streams.

        Args:
            eventid (str):
                ID of event to search for in ASDF file.
            stations (list):
                List of stations to create metrics for.
            labels (list):
                List of processing labels to create metrics for.
            imclist (list):
                List of valid component names.
            imtlist (list):
                List of valid IMT names.
            origin (obspy event origin object):
                Origin object for the event.
        """
        if not self.hasEvent(eventid):
            fmt = 'No event matching %s found in workspace.'
            raise KeyError(fmt % eventid)

        streams = self.getStreams(eventid, stations=stations, labels=labels)
        event = self.getEvent(eventid)
        for stream in streams:
            tag = stream.tag
            station, label = tag.split('_')
            if imclist is None and imtlist is None:
                summary = StationSummary.from_config(stream,
                                                     event=event)
            else:
                summary = StationSummary.from_stream(stream,
                                                     components=imclist,
                                                     imts=imtlist,
                                                     event=event)
            xmlstr = summary.getMetricXML()

            path = '%s_%s_%s' % (eventid, summary.station_code.lower(), label)

            # this seems like a lot of effort
            # just to store a string in HDF, but other
            # approached failed. Suggestions are welcome.
            jsonarray = np.frombuffer(xmlstr, dtype=np.uint8)
            dtype = 'WaveFormMetrics'
            self.dataset.add_auxiliary_data(jsonarray,
                                            data_type=dtype,
                                            path=path,
                                            parameters={})
Exemple #5
0
    def getStreamMetrics(self, eventid, station, label):
        """Extract a StationSummary object from the ASDF file for a given input Stream.

        Args:
            eventid (str):
                ID of event to search for in ASDF file.
            station (str):
                Station to return metrics from.
            label (str):
                Processing label to return metrics from.

        Returns:
            StationSummary: Object containing all stream metrics.
        """
        if 'WaveFormMetrics' not in self.dataset.auxiliary_data:
            raise KeyError('Waveform metrics not found in workspace.')
        auxholder = self.dataset.auxiliary_data.WaveFormMetrics
        stream_path = '%s_%s_%s' % (eventid, station.lower(), label)
        if stream_path not in auxholder:
            fmt = 'Waveform metrics for event %s and stream %s not found in workspace.'
            raise KeyError(fmt % (eventid, tag))
        bytelist = auxholder[stream_path].data[:].tolist()
        xmlstr = ''.join([chr(b) for b in bytelist])
        summary = StationSummary.fromMetricXML(xmlstr.encode('utf-8'))
        return summary
Exemple #6
0
def test_rotd():
    ddir = os.path.join('data', 'testdata', 'process')
    datadir = pkg_resources.resource_filename('gmprocess', ddir)
    # Create a stream and station summary, convert from m/s^2 to cm/s^2 (GAL)
    osc1_data = np.genfromtxt(datadir + '/ALCTENE.UW..sac.acc.final.txt')
    osc2_data = np.genfromtxt(datadir + '/ALCTENN.UW..sac.acc.final.txt')
    osc1_data = osc1_data.T[1] * 100
    osc2_data = osc2_data.T[1] * 100
    tr1 = Trace(data=osc1_data, header={'channel': 'H1', 'delta': 0.01,
                                        'npts': 10400})
    tr2 = Trace(data=osc2_data, header={'channel': 'H2', 'delta': 0.01,
                                        'npts': 10400})
    st = Stream([tr1, tr2])

    target_pga50 = 4.12528265306
    target_sa1050 = 10.7362857143
    target_pgv50 = 6.239364
    target_sa0350 = 10.1434159021
    target_sa3050 = 1.12614169215
    station = StationSummary.from_stream(st, ['rotd50'],
                                         ['pga', 'pgv', 'sa0.3', 'sa1.0', 'sa3.0'])
    pgms = station.pgms
    np.testing.assert_allclose(pgms['PGA']['ROTD50.0'], target_pga50, atol=0.1)
    np.testing.assert_allclose(
        pgms['SA(1.0)']['ROTD50.0'], target_sa1050, atol=0.1)
    np.testing.assert_allclose(pgms['PGV']['ROTD50.0'], target_pgv50, atol=0.1)
    np.testing.assert_allclose(
        pgms['SA(0.3)']['ROTD50.0'], target_sa0350, atol=0.1)
    np.testing.assert_allclose(
        pgms['SA(3.0)']['ROTD50.0'], target_sa3050, atol=0.1)
Exemple #7
0
def test_pgv():
    datafiles, _ = read_data_dir(
        'geonet', 'us1000778i', '20161113_110259_WTMC_20.V2A')
    datafile_v2 = datafiles[0]
    stream_v2 = read_geonet(datafile_v2)[0]
    pgv_target = {}
    for trace in stream_v2:
        vtrace = trace.copy()
        vtrace.integrate()
        pgv_target[vtrace.stats['channel']] = np.abs(vtrace.max())

    # we've replaced HN1 etc. with H1 so channel names are not the same as
    # the original trace
    pgv_target['H1'] = pgv_target['HN1']
    pgv_target['H2'] = pgv_target['HN2']
    pgv_target['Z'] = pgv_target['HNZ']

    with warnings.catch_warnings():
        warnings.simplefilter("ignore")
        station_summary = StationSummary.from_stream(stream_v2,
                                                     ['channels', 'greater_of_two_horizontals',
                                                         'gmrotd50'],
                                                     ['pgv', 'sa1.0', 'saincorrect'])
    pgv_df = station_summary.pgms.loc['PGV']
    HN1 = pgv_df.loc['H1'].Result
    HN2 = pgv_df.loc['H2'].Result
    HNZ = pgv_df.loc['Z'].Result
    np.testing.assert_almost_equal(HN2, pgv_target['H2'])
    np.testing.assert_almost_equal(HN1, pgv_target['H1'])
    np.testing.assert_almost_equal(HNZ, pgv_target['Z'])
def test_pga():
    datafiles, _ = read_data_dir(
        'geonet', 'us1000778i', '20161113_110259_WTMC_20.V2A')
    datafile_v2 = datafiles[0]
    stream_v2 = read_geonet(datafile_v2)[0]
    with warnings.catch_warnings():
        warnings.simplefilter("ignore")
        station_summary = StationSummary.from_stream(
            stream_v2,
            ['channels', 'greater_of_two_horizontals', 'gmrotd50',
             'gmrotd100', 'gmrotd0', 'rotd50', 'geometric_mean',
             'arithmetic_mean'],
            ['pga', 'sa1.0', 'saincorrect'])
    pga_df = station_summary.pgms.loc['PGA']
    AM = pga_df.loc['ARITHMETIC_MEAN'].Result
    GM = pga_df.loc['GEOMETRIC_MEAN'].Result
    HN1 = pga_df.loc['H1'].Result
    HN2 = pga_df.loc['H2'].Result
    HNZ = pga_df.loc['Z'].Result
    greater = pga_df.loc['GREATER_OF_TWO_HORIZONTALS'].Result
    np.testing.assert_allclose(
        AM, 90.242335558014219, rtol=1e-3)
    np.testing.assert_allclose(
        GM, 89.791654017670112, rtol=1e-3)
    np.testing.assert_allclose(
        HN2, 81.234672390673683, rtol=1e-3)
    np.testing.assert_allclose(
        HN1, 99.249998725354743, rtol=1e-3)
    np.testing.assert_almost_equal(
        HNZ, 183.77223618666929, decimal=1)
    np.testing.assert_allclose(
        greater, 99.249998725354743, rtol=1e-3)
Exemple #9
0
def test_sa():
    datafiles, _ = read_data_dir('geonet', 'us1000778i',
                                 '20161113_110259_WTMC_20.V2A')
    datafile_v2 = datafiles[0]
    stream_v2 = read_geonet(datafile_v2)[0]
    sa_target = {}
    for trace in stream_v2:
        vtrace = trace.copy()
        vtrace.integrate()
        sa_target[vtrace.stats['channel']] = np.abs(vtrace.max())
    with warnings.catch_warnings():
        warnings.simplefilter("ignore")
        station_summary = StationSummary.from_stream(stream_v2, [
            'greater_of_two_horizontals', 'geometric_mean', 'rotd50',
            'arithmetic_mean', 'rotd100', 'gmrotd50', 'channels'
        ], ['sa1.0', 'saincorrect'])
    pgms = station_summary.pgms
    assert 'SA(1.000)' in pgms.IMT.tolist()
    np.testing.assert_allclose(
        pgms[pgms['IMC'] == 'ARITHMETIC_MEAN'].Result.iloc[0],
        110.47168962900042)
    np.testing.assert_allclose(
        pgms[pgms['IMC'] == 'GEOMETRIC_MEAN'].Result.iloc[0],
        107.42183990654802)
    np.testing.assert_allclose(
        pgms[pgms['IMC'] == 'ROTD(50.0)'].Result.iloc[0], 106.03202302692158)
    np.testing.assert_allclose(
        pgms[pgms['IMC'] == 'ROTD(100.0)'].Result.iloc[0], 146.90233501240979)
def test_get_peak_time():
    datafiles, _ = read_data_dir("geonet", "us1000778i",
                                 "20161113_110259_WTMC_20.V2A")
    datafile = datafiles[0]
    stream1 = read_geonet(datafile)[0]
    max_cls = Max(stream1).result
    assert len(max_cls) == 2

    max_cls = Max({"chan": [0, 1, 2, 3]}).result
    assert len(max_cls) == 1

    stream2 = read_geonet(datafile)[0]
    origin = Origin(latitude=42.6925, longitude=173.021944)
    stream_summary = StationSummary.from_stream(stream2, ["channels"],
                                                ["pgv", "pga"], origin)
    assert stream2[0].stats.pga_time == UTCDateTime(
        "2016-11-13T11:03:08.880001Z")
    assert stream2[0].stats.pgv_time == UTCDateTime(
        "2016-11-13T11:03:10.580001Z")

    assert stream2[1].stats.pga_time == UTCDateTime(
        "2016-11-13T11:03:09.960001Z")
    assert stream2[1].stats.pgv_time == UTCDateTime(
        "2016-11-13T11:03:08.860001Z")

    assert stream2[2].stats.pga_time == UTCDateTime(
        "2016-11-13T11:03:08.140001Z")
    assert stream2[2].stats.pgv_time == UTCDateTime(
        "2016-11-13T11:03:09.560001Z")
def test_exceptions():
    datafiles, _ = read_data_dir("geonet", "us1000778i",
                                 "20161113_110259_WTMC_20.V2A")
    datafile_v2 = datafiles[0]
    stream_v2 = read_geonet(datafile_v2)[0]
    stream1 = stream_v2.select(channel="HN1")
    pgms = StationSummary.from_stream(stream1, ["rotd50"], ["pga"]).pgms
    assert np.isnan(pgms.loc["PGA", "ROTD(50.0)"].Result)
Exemple #12
0
def test_allow_nans():
    dpath = os.path.join('data', 'testdata', 'fdsn', 'uu60363602')
    datadir = pkg_resources.resource_filename('gmprocess', dpath)
    sc = StreamCollection.from_directory(datadir)
    origin = read_event_json_files([os.path.join(datadir, 'event.json')])[0]
    psc = process_streams(sc, origin)
    st = psc[0]

    ss = StationSummary.from_stream(
        st, components=['quadratic_mean'], imts=['FAS(4.0)'], bandwidth=189,
        allow_nans=True)
    assert np.isnan(ss.pgms.Result).all()

    ss = StationSummary.from_stream(
        st, components=['quadratic_mean'], imts=['FAS(4.0)'], bandwidth=189,
        allow_nans=False)
    assert ~np.isnan(ss.pgms.Result).all()
def test_exceptions():
    datafiles, _ = read_data_dir(
        'geonet', 'us1000778i', '20161113_110259_WTMC_20.V2A')
    datafile_v2 = datafiles[0]
    stream_v2 = read_geonet(datafile_v2)[0]
    stream1 = stream_v2.select(channel="HN1")
    pgms = StationSummary.from_stream(stream1, ['rotd50'], ['pga']).pgms
    assert np.isnan(pgms[(pgms.IMT == 'PGA') & (pgms.IMC == 'ROTD(50.0)')].Result.iloc[0])
Exemple #14
0
def test_exceptions():
    datafiles, _ = read_data_dir(
        'geonet', 'us1000778i', '20161113_110259_WTMC_20.V2A')
    datafile_v2 = datafiles[0]
    stream_v2 = read_geonet(datafile_v2)[0]
    stream1 = stream_v2.select(channel="HN1")
    pgms = StationSummary.from_stream(stream1, ['rotd50'], ['pga']).pgms
    assert np.isnan(pgms.loc['PGA', 'ROTD(50.0)'].Result)
def test_gmrotd():
    datafiles, _ = read_data_dir(
        'geonet', 'us1000778i', '20161113_110259_WTMC_20.V2A')
    datafile_v2 = datafiles[0]

    stream_v2 = read_geonet(datafile_v2)[0]
    station_summary = StationSummary.from_stream(stream_v2,
                                                 ['gmrotd0', 'gmrotd50',
                                                  'gmrotd100'], ['pga'])
def test_gmrotd():
    datafiles, _ = read_data_dir("geonet", "us1000778i",
                                 "20161113_110259_WTMC_20.V2A")
    datafile_v2 = datafiles[0]

    stream_v2 = read_geonet(datafile_v2)[0]
    station_summary = StationSummary.from_stream(
        stream_v2, ["gmrotd0", "gmrotd50", "gmrotd100"], ["pga"])
    pgms = station_summary.pgms
    assert "GMROTD(50.0)" in pgms.index.get_level_values(1)
Exemple #17
0
def test_gmrotd():
    datafiles, _ = read_data_dir('geonet', 'us1000778i',
                                 '20161113_110259_WTMC_20.V2A')
    datafile_v2 = datafiles[0]

    stream_v2 = read_geonet(datafile_v2)[0]
    station_summary = StationSummary.from_stream(
        stream_v2, ['gmrotd0', 'gmrotd50', 'gmrotd100'], ['pga'])
    pgms = station_summary.pgms
    assert 'GMROTD(50.0)' in pgms.IMC.tolist()
def test_greater_of_two_horizontals():
    datafiles, _ = read_data_dir("geonet", "us1000778i",
                                 "20161113_110259_WTMC_20.V2A")
    datafile_v2 = datafiles[0]
    stream_v2 = read_geonet(datafile_v2)[0]
    station_summary = StationSummary.from_stream(
        stream_v2, ["greater_of_two_horizontals"], ["pga"])
    pgms = station_summary.pgms
    greater = pgms.loc["PGA", "GREATER_OF_TWO_HORIZONTALS"].Result
    np.testing.assert_almost_equal(greater, 99.3173469387755, decimal=1)
def test_greater_of_two_horizontals():
    datafiles, _ = read_data_dir(
        'geonet', 'us1000778i', '20161113_110259_WTMC_20.V2A')
    datafile_v2 = datafiles[0]
    stream_v2 = read_geonet(datafile_v2)[0]
    station_summary = StationSummary.from_stream(stream_v2,
                                                 ['greater_of_two_horizontals'], ['pga'])
    station = station_summary.pgms[station_summary.pgms.IMT == 'PGA']
    greater = station[station.IMC == 'GREATER_OF_TWO_HORIZONTALS'].Result.iloc[0]
    np.testing.assert_almost_equal(greater, 99.3173469387755, decimal=1)
def test_greater_of_two_horizontals():
    datafiles, _ = read_data_dir('geonet', 'us1000778i',
                                 '20161113_110259_WTMC_20.V2A')
    datafile_v2 = datafiles[0]
    stream_v2 = read_geonet(datafile_v2)[0]
    station_summary = StationSummary.from_stream(
        stream_v2, ['greater_of_two_horizontals'], ['pga'])
    pgms = station_summary.pgms
    greater = pgms.loc['PGA', 'GREATER_OF_TWO_HORIZONTALS'].Result
    np.testing.assert_almost_equal(greater, 99.3173469387755, decimal=1)
Exemple #21
0
def test_arias():
    ddir = os.path.join('data', 'testdata')
    datadir = pkg_resources.resource_filename('gmprocess', ddir)
    data_file = os.path.join(datadir, 'arias_data.json')
    with open(data_file, 'rt') as f:
        jdict = json.load(f)

    time = np.array(jdict['time'])
    # input output is m/s/s
    acc = np.array(jdict['acc']) / 100
    target_IA = jdict['ia']
    delta = time[2] - time[1]
    sr = 1 / delta
    header = {
        'delta': delta,
        'sampling_rate': sr,
        'npts': len(acc),
        'units': 'm/s/s',
        'channel': 'H1'
    }
    trace = Trace(data=acc, header=header)
    stream = Stream([trace])
    Ia = calculate_arias(stream, ['channels'])['H1']
    # the target has only one decimal place and is in cm/s/s
    Ia = Ia * 100
    np.testing.assert_almost_equal(Ia, target_IA, decimal=1)

    # input is cm/s/s output is m/s/s
    trace = Trace(data=acc * 100, header=header)
    stream = Stream([trace])
    station = StationSummary.from_stream(stream, ['channels'], ['arias'])
    Ia = station.pgms['ARIAS']['H1']
    # the target has only one decimal place and is in cm/s/s
    Ia = Ia * 100
    np.testing.assert_almost_equal(Ia, target_IA, decimal=1)

    # Test other components
    data_files, _ = read_data_dir('cwb', 'us1000chhc', '2-ECU.dat')
    stream = read_data(data_files[0])[0]
    station = StationSummary.from_stream(
        stream, ['channels', 'gmrotd', 'rotd50', 'greater_of_two_horizontals'],
        ['arias'])
    def calcStreamMetrics(self,
                          eventid,
                          stations=None,
                          labels=None,
                          config=None):
        """Create station metrics for specified event/streams.

        Args:
            eventid (str):
                ID of event to search for in ASDF file.
            stations (list):
                List of stations to create metrics for.
            labels (list):
                List of processing labels to create metrics for.
            imclist (list):
                List of valid component names.
            imtlist (list):
                List of valid IMT names.
            config (dict):
                Config dictionary.
        """
        if not self.hasEvent(eventid):
            fmt = 'No event matching %s found in workspace.'
            raise KeyError(fmt % eventid)

        streams = self.getStreams(eventid, stations=stations, labels=labels)
        event = self.getEvent(eventid)
        for stream in streams:
            tag = stream.tag
            eventid, station, label = tag.split('_')
            try:
                summary = StationSummary.from_config(stream,
                                                     event=event,
                                                     config=config)
            except Exception as pgme:
                fmt = 'Could not create stream metrics for event %s, station %s: "%s"'
                logging.warning(fmt % (eventid, station, str(pgme)))
                continue

            xmlstr = summary.get_metric_xml()

            path = '%s_%s_%s' % (eventid, summary.station_code.lower(), label)

            # this seems like a lot of effort
            # just to store a string in HDF, but other
            # approached failed. Suggestions are welcome.
            xmlbytes = xmlstr.encode('utf-8')
            jsonarray = np.frombuffer(xmlbytes, dtype=np.uint8)
            dtype = 'WaveFormMetrics'

            self.dataset.add_auxiliary_data(jsonarray,
                                            data_type=dtype,
                                            path=path,
                                            parameters={})
def test_gmrotd():
    datafiles, _ = read_data_dir(
        'geonet', 'us1000778i', '20161113_110259_WTMC_20.V2A')
    datafile_v2 = datafiles[0]

    stream_v2 = read_geonet(datafile_v2)[0]
    station_summary = StationSummary.from_stream(stream_v2,
                                                 ['gmrotd0', 'gmrotd50',
                                                  'gmrotd100'], ['pga'])
    pgms = station_summary.pgms
    assert 'GMROTD(50.0)' in pgms.IMC.tolist()
Exemple #24
0
def test_exceptions():
    datafiles, _ = read_data_dir(
        'geonet', 'us1000778i', '20161113_110259_WTMC_20.V2A')
    datafile_v2 = datafiles[0]
    stream_v2 = read_geonet(datafile_v2)[0]
    stream1 = stream_v2.select(channel="HN1")
    try:
        StationSummary.from_stream(stream1, ['rotd50'], ['pga'])
        sucess = True
    except PGMException:
        sucess = False
    assert sucess == False

    stream2 = Stream(
        [stream_v2.select(channel="HN1")[0],
            Trace(data=np.asarray([]), header={"channel": "HN2"})])
    try:
        StationSummary.from_stream(stream2,
                                   ['rotd50'], ['pga'])
        sucess = True
    except PGMException:
        sucess = False
    assert sucess == False

    for trace in stream_v2:
        stream1.append(trace)
    try:
        StationSummary.from_stream(stream1, ['rotd50'], ['pga'])
        sucess = True
    except PGMException:
        sucess = False
    assert sucess == False
Exemple #25
0
def test_sorted_duration():
    ddir = os.path.join('data', 'testdata', 'cosmos', 'us1000hyfh')
    datadir = pkg_resources.resource_filename('gmprocess', ddir)
    data_file = os.path.join(
        datadir, 'us1000hyfh_akbmrp_AKBMR--n.1000hyfh.BNZ.--.acc.V2c')
    stream = read_data(data_file)[0]

    station = StationSummary.from_stream(stream, ['channels'],
                                         ['sorted_duration'])
    pgms = station.pgms
    sorted_duration = pgms.loc['SORTED_DURATION', 'CHANNELS'].Result

    np.testing.assert_allclose(sorted_duration, 36.805, atol=1e-4, rtol=1e-4)
def test_sorted_duration():
    ddir = os.path.join("data", "testdata", "cosmos", "us1000hyfh")
    datadir = pkg_resources.resource_filename("gmprocess", ddir)
    data_file = os.path.join(
        datadir, "us1000hyfh_akbmrp_AKBMR--n.1000hyfh.BNZ.--.acc.V2c")
    stream = read_data(data_file)[0]

    station = StationSummary.from_stream(stream, ["channels"],
                                         ["sorted_duration"])
    pgms = station.pgms
    sorted_duration = pgms.loc["SORTED_DURATION", "CHANNELS"].Result

    np.testing.assert_allclose(sorted_duration, 36.805, atol=1e-4, rtol=1e-4)
Exemple #27
0
def test_channels():
    datafiles, _ = read_data_dir(
        'geonet', 'us1000778i', '20161113_110259_WTMC_20.V2A')
    datafile_v2 = datafiles[0]
    stream_v2 = read_geonet(datafile_v2)[0]
    station_summary = StationSummary.from_stream(stream_v2,
                                                 ['channels'], ['pga'])
    channel = station_summary.pgms[station_summary.pgms.IMT == 'PGA']
    np.testing.assert_almost_equal(
        channel[channel.IMC == 'HN2'].Result.iloc[0], 81.28979591836733, decimal=1)
    np.testing.assert_almost_equal(
        channel[channel.IMC == 'HN1'].Result.iloc[0], 99.3173469387755, decimal=1)
    np.testing.assert_almost_equal(
        channel[channel.IMC == 'HNZ'].Result.iloc[0], 183.89693877551022, decimal=1)
Exemple #28
0
def test_channels():
    datafiles, _ = read_data_dir(
        'geonet', 'us1000778i', '20161113_110259_WTMC_20.V2A')
    datafile_v2 = datafiles[0]
    stream_v2 = read_geonet(datafile_v2)[0]
    station_summary = StationSummary.from_stream(stream_v2,
                                                 ['channels'], ['pga'])
    pgms = station_summary.pgms
    np.testing.assert_almost_equal(
        pgms.loc['PGA', 'H2'].Result, 81.28979591836733, decimal=1)
    np.testing.assert_almost_equal(
        pgms.loc['PGA', 'H1'].Result, 99.3173469387755, decimal=1)
    np.testing.assert_almost_equal(
        pgms.loc['PGA', 'Z'].Result, 183.89693877551022, decimal=1)
Exemple #29
0
    def setStreamMetrics(self,
                         eventid,
                         stations=None,
                         labels=None,
                         imclist=None,
                         imtlist=None,
                         origin=None):
        """Create station metrics for specified event/streams.

        Args:
            eventid (str):
                ID of event to search for in ASDF file.
            stations (list):
                List of stations to create metrics for.
            labels (list):
                List of processing labels to create metrics for.
            imclist (list):
                List of valid component names.
            imtlist (list):
                List of valid IMT names.
            origin (obspy event origin object):
                Origin object for the event.
        """
        if not self.hasEvent(eventid):
            fmt = 'No event matching %s found in workspace.'
            raise KeyError(fmt % eventid)

        streams = self.getStreams(eventid, stations=stations, labels=labels)

        for stream in streams:
            tag = stream.tag
            station, label = tag.split('_')
            summary = StationSummary.from_stream(stream,
                                                 components=imclist,
                                                 imts=imtlist,
                                                 origin=origin)
            xmlstr = summary.getMetricXML()

            path = '%s_%s_%s' % (eventid, summary.station_code.lower(), label)

            # this seems like a lot of effort
            # just to store a string in HDF, but other
            # approached failed. Suggestions are welcome.
            jsonarray = np.frombuffer(xmlstr, dtype=np.uint8)
            dtype = 'WaveFormMetrics'
            self.dataset.add_auxiliary_data(jsonarray,
                                            data_type=dtype,
                                            path=path,
                                            parameters={})
Exemple #30
0
def test_channels():
    datafiles, _ = read_data_dir("geonet", "us1000778i", "20161113_110259_WTMC_20.V2A")
    datafile_v2 = datafiles[0]
    stream_v2 = read_geonet(datafile_v2)[0]
    station_summary = StationSummary.from_stream(stream_v2, ["channels"], ["pga"])
    pgms = station_summary.pgms
    np.testing.assert_almost_equal(
        pgms.loc["PGA", "H2"].Result, 81.28979591836733, decimal=1
    )
    np.testing.assert_almost_equal(
        pgms.loc["PGA", "H1"].Result, 99.3173469387755, decimal=1
    )
    np.testing.assert_almost_equal(
        pgms.loc["PGA", "Z"].Result, 183.89693877551022, decimal=1
    )
Exemple #31
0
    def _compute_event_waveforms(self, event):
        self.eventid = event.id
        logging.info(
            'Computing waveform metrics for event %s...' % self.eventid)
        event_dir = os.path.join(self.gmrecords.data_path, self.eventid)
        workname = os.path.join(event_dir, WORKSPACE_NAME)
        if not os.path.isfile(workname):
            logging.info(
                'No workspace file found for event %s. Please run '
                'subcommand \'assemble\' to generate workspace file.'
                % self.eventid)
            logging.info('Continuing to next event.')
            return event.id

        self.workspace = StreamWorkspace.open(workname)
        self._get_pstreams()

        if not hasattr(self, 'pstreams'):
            logging.info('No processed waveforms available. No waveform '
                         'metrics computed.')
            self.workspace.close()
            return event.id

        for stream in self.pstreams:
            if stream.passed:
                logging.info(
                    'Calculating waveform metrics for %s...'
                    % stream.get_id()
                )
                summary = StationSummary.from_config(
                    stream, event=event, config=self.gmrecords.conf,
                    calc_waveform_metrics=True,
                    calc_station_metrics=False
                )
                xmlstr = summary.get_metric_xml()
                tag = stream.tag
                metricpath = '/'.join([
                    format_netsta(stream[0].stats),
                    format_nslit(stream[0].stats, stream.get_inst(), tag)
                ])
                self.workspace.insert_aux(
                    xmlstr, 'WaveFormMetrics', metricpath,
                    overwrite=self.gmrecords.args.overwrite)
            logging.info('Added waveform metrics to workspace files '
                         'with tag \'%s\'.' % self.gmrecords.args.label)

        self.workspace.close()
        return event.id
def test_metrics():
    eventid = 'usb000syza'
    datafiles, event = read_data_dir('knet', eventid, '*')
    datadir = os.path.split(datafiles[0])[0]
    raw_streams = StreamCollection.from_directory(datadir)
    config = update_config(os.path.join(datadir, 'config_min_freq_0p2.yml'))
    # turn off sta/lta check and snr checks
    # newconfig = drop_processing(config, ['check_sta_lta', 'compute_snr'])
    # processed_streams = process_streams(raw_streams, event, config=newconfig)
    newconfig = config.copy()
    newconfig['processing'].append(
        {'NNet_QA': {
            'acceptance_threshold': 0.5,
            'model_name': 'CantWell'
        }})
    processed_streams = process_streams(raw_streams.copy(),
                                        event,
                                        config=newconfig)

    tdir = tempfile.mkdtemp()
    try:
        tfile = os.path.join(tdir, 'test.hdf')
        workspace = StreamWorkspace(tfile)
        workspace.addEvent(event)
        workspace.addStreams(event, raw_streams, label='raw')
        workspace.addStreams(event, processed_streams, label='processed')
        stream1 = raw_streams[0]

        # Get metrics from station summary for raw streams
        summary1 = StationSummary.from_config(stream1)
        s1_df_in = summary1.pgms.sort_values(['IMT', 'IMC'])
        array1 = s1_df_in['Result'].to_numpy()

        # Compare to metrics from getStreamMetrics for raw streams
        workspace.calcMetrics(eventid, labels=['raw'])
        summary1_a = workspace.getStreamMetrics(event.id,
                                                stream1[0].stats.network,
                                                stream1[0].stats.station,
                                                'raw')
        s1_df_out = summary1_a.pgms.sort_values(['IMT', 'IMC'])
        array2 = s1_df_out['Result'].to_numpy()

        np.testing.assert_allclose(array1, array2, atol=1e-6, rtol=1e-6)
        workspace.close()
    except Exception as e:
        raise (e)
    finally:
        shutil.rmtree(tdir)
Exemple #33
0
def test_metrics():
    eventid = "usb000syza"
    datafiles, event = read_data_dir("knet", eventid, "*")
    datadir = os.path.split(datafiles[0])[0]
    raw_streams = StreamCollection.from_directory(datadir)
    config = update_config(os.path.join(datadir, "config_min_freq_0p2.yml"))
    # turn off sta/lta check and snr checks
    # newconfig = drop_processing(config, ['check_sta_lta', 'compute_snr'])
    # processed_streams = process_streams(raw_streams, event, config=newconfig)
    newconfig = config.copy()
    newconfig["processing"].append(
        {"NNet_QA": {
            "acceptance_threshold": 0.5,
            "model_name": "CantWell"
        }})
    processed_streams = process_streams(raw_streams.copy(),
                                        event,
                                        config=newconfig)

    tdir = tempfile.mkdtemp()
    try:
        tfile = os.path.join(tdir, "test.hdf")
        workspace = StreamWorkspace(tfile)
        workspace.addEvent(event)
        workspace.addStreams(event, raw_streams, label="raw")
        workspace.addStreams(event, processed_streams, label="processed")
        stream1 = raw_streams[0]

        # Get metrics from station summary for raw streams
        summary1 = StationSummary.from_config(stream1)
        s1_df_in = summary1.pgms.sort_values(["IMT", "IMC"])
        array1 = s1_df_in["Result"].to_numpy()

        # Compare to metrics from getStreamMetrics for raw streams
        workspace.calcMetrics(eventid, labels=["raw"])
        summary1_a = workspace.getStreamMetrics(event.id,
                                                stream1[0].stats.network,
                                                stream1[0].stats.station,
                                                "raw")
        s1_df_out = summary1_a.pgms.sort_values(["IMT", "IMC"])
        array2 = s1_df_out["Result"].to_numpy()

        np.testing.assert_allclose(array1, array2, atol=1e-6, rtol=1e-6)
        workspace.close()
    except Exception as e:
        raise (e)
    finally:
        shutil.rmtree(tdir)
Exemple #34
0
def test_sa():
    datafiles, _ = read_data_dir('geonet', 'us1000778i',
                                 '20161113_110259_WTMC_20.V2A')
    datafile_v2 = datafiles[0]
    stream_v2 = read_geonet(datafile_v2)[0]
    sa_target = {}
    for trace in stream_v2:
        vtrace = trace.copy()
        vtrace.integrate()
        sa_target[vtrace.stats['channel']] = np.abs(vtrace.max())
    with warnings.catch_warnings():
        warnings.simplefilter("ignore")
        station_summary = StationSummary.from_stream(
            stream_v2, ['greater_of_two_horizontals', 'gmrotd50', 'channels'],
            ['sa1.0', 'saincorrect'])
    assert 'SA(1.0)' in station_summary.pgms
def test_metrics():
    eventid = 'usb000syza'
    datafiles, event = read_data_dir('knet', eventid, '*')
    datadir = os.path.split(datafiles[0])[0]
    raw_streams = StreamCollection.from_directory(datadir)
    config = get_config()
    # turn off sta/lta check and snr checks
    # newconfig = drop_processing(config, ['check_sta_lta', 'compute_snr'])
    # processed_streams = process_streams(raw_streams, event, config=newconfig)
    newconfig = config.copy()
    newconfig['processing'].append(
        {'NNet_QA': {
            'acceptance_threshold': 0.5,
            'model_name': 'CantWell'
        }})
    processed_streams = process_streams(raw_streams, event, config=newconfig)

    tdir = tempfile.mkdtemp()
    try:
        tfile = os.path.join(tdir, 'test.hdf')
        workspace = StreamWorkspace(tfile)
        workspace.addEvent(event)
        workspace.addStreams(event, raw_streams, label='raw')
        workspace.addStreams(event, processed_streams, label='processed')
        stream1 = raw_streams[0]
        summary1 = StationSummary.from_config(stream1)
        s1_df_in = summary1.pgms.sort_values(['IMT', 'IMC'])
        array1 = s1_df_in['Result'].as_matrix()
        workspace.calcStreamMetrics(eventid, labels=['raw'])
        workspace.calcStationMetrics(event.id, labels=['raw'])
        pstreams2 = workspace.getStreams(event.id, labels=['processed'])
        assert pstreams2[0].getStreamParamKeys() == ['nnet_qa']
        summary1_a = workspace.getStreamMetrics(event.id,
                                                stream1[0].stats.network,
                                                stream1[0].stats.station,
                                                'raw')
        s1_df_out = summary1_a.pgms.sort_values(['IMT', 'IMC'])
        array2 = s1_df_out['Result'].as_matrix()
        np.testing.assert_almost_equal(array1, array2, decimal=4)

        workspace.close()
    except Exception as e:
        raise (e)
    finally:
        shutil.rmtree(tdir)
    def getStreamMetrics(self, eventid, station, label):
        """Extract a StationSummary object from the ASDF file for a given input Stream.

        Args:
            eventid (str):
                ID of event to search for in ASDF file.
            station (str):
                Station to return metrics from.
            label (str):
                Processing label to return metrics from.

        Returns:
            StationSummary: Object containing all stream metrics.
        """
        if 'WaveFormMetrics' not in self.dataset.auxiliary_data:
            logging.warning('Waveform metrics not found in workspace, '
                            'cannot get stream metrics.')
        auxholder = self.dataset.auxiliary_data.WaveFormMetrics
        stream_path = '%s_%s_%s' % (eventid, station.lower(), label)
        if stream_path not in auxholder:
            logging.warning(
                'Stream path (%s) not in WaveFormMetrics auxiliary_data.' %
                stream_path)
            return

        bytelist = auxholder[stream_path].data[:].tolist()
        xml_stream = ''.join([chr(b) for b in bytelist])
        xml_stream = xml_stream.encode('utf-8')

        if 'StationMetrics' not in self.dataset.auxiliary_data:
            raise KeyError('Station metrics not found in workspace.')
        auxholder = self.dataset.auxiliary_data.StationMetrics
        stream_path = '%s_%s_%s' % (eventid, station.lower(), label)
        if stream_path not in auxholder:
            logging.warning(
                'Stream path (%s) not in StationMetrics auxiliary_data.' %
                stream_path)
            return

        bytelist = auxholder[stream_path].data[:].tolist()
        xml_station = ''.join([chr(b) for b in bytelist])
        xml_station = xml_station.encode('utf-8')

        summary = StationSummary.from_xml(xml_stream, xml_station)
        return summary
def test_sa():
    datafiles, _ = read_data_dir("geonet", "us1000778i", "20161113_110259_WTMC_20.V2A")
    datafile_v2 = datafiles[0]
    stream_v2 = read_geonet(datafile_v2)[0]
    sa_target = {}
    for trace in stream_v2:
        vtrace = trace.copy()
        vtrace.integrate()
        sa_target[vtrace.stats["channel"]] = np.abs(vtrace.max())
    with warnings.catch_warnings():
        warnings.simplefilter("ignore")
        station_summary = StationSummary.from_stream(
            stream_v2,
            [
                "greater_of_two_horizontals",
                "geometric_mean",
                "rotd50",
                "arithmetic_mean",
                "rotd100",
                "gmrotd50",
                "channels",
            ],
            ["sa1.0", "sa0.01", "saincorrect"],
        )
    pgms = station_summary.pgms
    assert "SA(1.000)" in pgms.index.get_level_values(0)
    np.testing.assert_allclose(
        pgms.loc["SA(1.000)", "ARITHMETIC_MEAN"].Result, 110.47168962900042
    )
    np.testing.assert_allclose(
        pgms.loc["SA(1.000)", "GEOMETRIC_MEAN"].Result, 107.42183990654802
    )
    np.testing.assert_allclose(
        pgms.loc["SA(1.000)", "ROTD(50.0)"].Result, 106.03202302692158
    )
    np.testing.assert_allclose(
        pgms.loc["SA(1.000)", "ROTD(100.0)"].Result, 146.90233501240979
    )
    # Check high frequency SA
    np.testing.assert_allclose(pgms.loc["SA(0.010)", "ROTD(100.0)"].Result, 120.187153)
    np.testing.assert_allclose(pgms.loc["SA(0.010)", "GMROTD(50.0)"].Result, 95.355300)
    np.testing.assert_allclose(pgms.loc["SA(0.010)", "H1"].Result, 106.716122)
    np.testing.assert_allclose(pgms.loc["SA(0.010)", "H2"].Result, 90.497883)
    np.testing.assert_allclose(pgms.loc["SA(0.010)", "GMROTD(50.0)"].Result, 95.355300)
def test_pgv():
    datafiles, _ = read_data_dir(
        'geonet', 'us1000778i', '20161113_110259_WTMC_20.V2A')
    datafile_v2 = datafiles[0]
    stream_v2 = read_geonet(datafile_v2)[0]
    pgv_target = {}
    for trace in stream_v2:
        vtrace = trace.copy()
        vtrace.integrate()
        pgv_target[vtrace.stats['channel']] = np.abs(vtrace.max())
    with warnings.catch_warnings():
        warnings.simplefilter("ignore")
        station_summary = StationSummary.from_stream(stream_v2,
                                                     ['channels', 'greater_of_two_horizontals',
                                                         'gmrotd50'],
                                                     ['pgv', 'sa1.0', 'saincorrect'])
    pgv_df = station_summary.pgms[station_summary.pgms.IMT == 'PGV']
    HN1 = pgv_df[pgv_df.IMC == 'HN1'].Result.iloc[0]
    HN2 = pgv_df[pgv_df.IMC == 'HN2'].Result.iloc[0]
    HNZ = pgv_df[pgv_df.IMC == 'HNZ'].Result.iloc[0]
    np.testing.assert_almost_equal(HN2, pgv_target['HN2'])
    np.testing.assert_almost_equal(HN1, pgv_target['HN1'])
    np.testing.assert_almost_equal(HNZ, pgv_target['HNZ'])
def test_pga():
    datafiles, _ = read_data_dir(
        'geonet', 'us1000778i', '20161113_110259_WTMC_20.V2A')
    datafile_v2 = datafiles[0]
    stream_v2 = read_geonet(datafile_v2)[0]
    with warnings.catch_warnings():
        warnings.simplefilter("ignore")
        station_summary = StationSummary.from_stream(stream_v2,
                                                     ['channels', 'greater_of_two_horizontals', 'gmrotd50',
                                                      'gmrotd100', 'gmrotd0'],
                                                     ['pga', 'sa1.0', 'saincorrect'])
    pga_df = station_summary.pgms[station_summary.pgms.IMT == 'PGA']
    HN1 = pga_df[pga_df.IMC == 'HN1'].Result.iloc[0]
    HN2 = pga_df[pga_df.IMC == 'HN2'].Result.iloc[0]
    HNZ = pga_df[pga_df.IMC == 'HNZ'].Result.iloc[0]
    greater = pga_df[pga_df.IMC == 'GREATER_OF_TWO_HORIZONTALS'].Result.iloc[0]
    np.testing.assert_almost_equal(
        HN2, 81.28979591836733, decimal=1)
    np.testing.assert_almost_equal(
        HN1, 99.3173469387755, decimal=1)
    np.testing.assert_almost_equal(
        HNZ, 183.89693877551022, decimal=1)
    np.testing.assert_almost_equal(greater, 99.3173469387755, decimal=1)
def test_stationsummary():
    datafiles, _ = read_data_dir(
        'geonet', 'us1000778i', '20161113_110259_WTMC_20.V2A')
    datafile = datafiles[0]
    origin = Origin(latitude=42.6925, longitude=173.021944)

    target_imcs = np.sort(np.asarray(['GREATER_OF_TWO_HORIZONTALS',
                                      'HN1', 'HN2', 'HNZ', 'ROTD(50.0)',
                                      'ROTD(100.0)']))
    target_imts = np.sort(np.asarray(['SA(1.0)', 'PGA', 'PGV']))
    stream = read_geonet(datafile)[0]
    with warnings.catch_warnings():
        warnings.simplefilter("ignore")
        stream_summary = StationSummary.from_stream(
            stream,
            ['greater_of_two_horizontals',
             'channels',
             'rotd50',
             'rotd100',
             'invalid'],
            ['sa1.0', 'PGA', 'pgv', 'invalid'], origin)
        original_stream = stream_summary.stream
        stream_summary.stream = []
        final_stream = stream_summary.stream
        assert original_stream == final_stream
        original_code = stream_summary.station_code
        np.testing.assert_array_equal(np.sort(stream_summary.components),
                                      target_imcs)
        np.testing.assert_array_equal(np.sort(stream_summary.imts),
                                      target_imts)
        np.testing.assert_almost_equal(stream_summary.get_pgm('PGA', 'HN1'),
                                       99.3173469387755, decimal=1)
        target_available = np.sort(np.asarray([
            'greater_of_two_horizontals', 'geometric_mean', 'arithmetic_mean',
            'channels', 'gmrotd', 'rotd', 'quadratic_mean',
            'radial_transverse']))
        imcs = stream_summary.available_imcs
        np.testing.assert_array_equal(np.sort(imcs), target_available)
        target_available = np.sort(np.asarray(['pga',
                                               'pgv',
                                               'sa',
                                               'arias',
                                               'fas']))
        imts = stream_summary.available_imts
        np.testing.assert_array_equal(np.sort(imts), target_available)
    test_pgms = {
        'PGV': {
            'ROTD(100.0)': 114.24894584734818,
            'ROTD(50.0)': 81.55436750525355,
            'HNZ': 37.47740000000001,
            'HN1': 100.81460000000004,
            'HN2': 68.4354,
            'GREATER_OF_TWO_HORIZONTALS': 100.81460000000004},
        'PGA': {
            'ROTD(100.0)': 100.73875535385548,
            'ROTD(50.0)': 91.40178541935455,
            'HNZ': 183.7722361866693,
            'HN1': 99.24999872535474,
            'HN2': 81.23467239067368,
            'GREATER_OF_TWO_HORIZONTALS': 99.24999872535474},
        'SA(1.0)': {
            'ROTD(100.0)': 146.9023350124098,
            'ROTD(50.0)': 106.03202302692158,
            'HNZ': 27.74118995438756,
            'HN1': 136.25041187387063,
            'HN2': 84.69296738413021,
            'GREATER_OF_TWO_HORIZONTALS': 136.25041187387063}
    }
    pgms = stream_summary.pgms
    for imt_str in test_pgms:
        for imc_str in test_pgms[imt_str]:
            imt = pgms.loc[pgms['IMT'] == imt_str]
            imc = imt.loc[imt['IMC'] == imc_str]
            results = imc.Result.tolist()
            assert len(results) == 1
            np.testing.assert_almost_equal(results[0], test_pgms[imt_str][imc_str],
                    decimal=10)

    # Test with fas
    stream = read_geonet(datafile)[0]
    stream_summary = StationSummary.from_stream(
        stream,
        ['greater_of_two_horizontals',
         'channels',
         'geometric_mean'],
        ['sa1.0', 'PGA', 'pgv', 'fas2.0'])
    target_imcs = np.sort(np.asarray(['GREATER_OF_TWO_HORIZONTALS',
                                      'HN1', 'HN2', 'HNZ',
                                      'GEOMETRIC_MEAN']))
    target_imts = np.sort(np.asarray(['SA(1.0)',
                                      'PGA', 'PGV', 'FAS(2.0)']))
    np.testing.assert_array_equal(np.sort(stream_summary.components),
                                  target_imcs)
    np.testing.assert_array_equal(np.sort(stream_summary.imts),
                                  target_imts)

    # Test config use
    stream = read_geonet(datafile)[0]
    stream_summary = StationSummary.from_config(stream)
    target_imcs = np.sort(np.asarray(['GREATER_OF_TWO_HORIZONTALS',
                                      'HN1', 'HN2', 'HNZ']))
    target_imts = np.sort(np.asarray(['SA(1.0)', 'SA(2.0)', 'SA(3.0)',
                                      'SA(0.3)', 'PGA', 'PGV', 'FAS(1.0)', 'FAS(2.0)',
                                      'FAS(3.0)', 'FAS(0.3)']))
    assert(stream_summary.smoothing == 'konno_ohmachi')
    assert(stream_summary.bandwidth == 20.0)
    assert(stream_summary.damping == 0.05)

    # test XML output
    stream = read_geonet(datafile)[0]
    imclist = ['greater_of_two_horizontals',
               'channels',
               'rotd50.0',
               'rotd100.0']
    imtlist = ['sa1.0', 'PGA', 'pgv', 'fas2.0', 'arias']
    stream_summary = StationSummary.from_stream(stream, imclist, imtlist)
    xmlstr = stream_summary.getMetricXML()
    print(xmlstr.decode('utf-8'))

    stream2 = StationSummary.fromMetricXML(xmlstr)
    cmp1 = np.sort(['GREATER_OF_TWO_HORIZONTALS', 'HN1', 'HN2', 'HNZ',
            'ROTD100.0', 'ROTD50.0'])
    cmp2 = np.sort(stream2.components)
    np.testing.assert_array_equal(cmp1, cmp2)
    imt1 = np.sort(stream_summary.imts)
    imt2 = np.sort(stream2.imts)
    np.testing.assert_array_equal(imt1, imt2)
def streams_to_dataframe(streams, imcs=None, imts=None, event=None):
    """Extract peak ground motions from list of processed StationStream objects.

    Note: The PGM columns underneath each channel will be variable
    depending on the units of the Stream being passed in (velocity
    sensors can only generate PGV) and on the imtlist passed in by
    user. Spectral acceleration columns will be formatted as SA(0.3)
    for 0.3 second spectral acceleration, for example.

    Args:
        directory (str):
            Directory of ground motion files (streams).
        imcs (list):
            Strings designating desired components to create in table.
        imts (list):
            Strings designating desired PGMs to create in table.
        event (ScalarEvent): Defines the focal time, 
                geographic location, and magnitude of an earthquake hypocenter.
                Default is None.

    Returns:
        DataFrame: Pandas dataframe containing columns:
            - STATION Station code.
            - NAME Text description of station.
            - LOCATION Two character location code.
            - SOURCE Long form string containing source network.
            - NETWORK Short network code.
            - LAT Station latitude
            - LON Station longitude
            - DISTANCE Epicentral distance (km) (if epicentral
              lat/lon provided)
            - HN1 East-west channel (or H1) (multi-index with pgm columns):
                - PGA Peak ground acceleration (%g).
                - PGV Peak ground velocity (cm/s).
                - SA(0.3) Pseudo-spectral acceleration at 0.3 seconds (%g).
                - SA(1.0) Pseudo-spectral acceleration at 1.0 seconds (%g).
                - SA(3.0) Pseudo-spectral acceleration at 3.0 seconds (%g).
            - HN2 North-south channel (or H2) (multi-index with pgm columns):
                - PGA Peak ground acceleration (%g).
                - PGV Peak ground velocity (cm/s).
                - SA(0.3) Pseudo-spectral acceleration at 0.3 seconds (%g).
                - SA(1.0) Pseudo-spectral acceleration at 1.0 seconds (%g).
                - SA(3.0) Pseudo-spectral acceleration at 3.0 seconds (%g).
            - HNZ Vertical channel (or HZ) (multi-index with pgm columns):
                - PGA Peak ground acceleration (%g).
                - PGV Peak ground velocity (cm/s).
                - SA(0.3) Pseudo-spectral acceleration at 0.3 seconds (%g).
                - SA(1.0) Pseudo-spectral acceleration at 1.0 seconds (%g).
                - SA(3.0) Pseudo-spectral acceleration at 3.0 seconds (%g).
            - GREATER_OF_TWO_HORIZONTALS (multi-index with pgm columns):
                - PGA Peak ground acceleration (%g).
                - PGV Peak ground velocity (cm/s).
                - SA(0.3) Pseudo-spectral acceleration at 0.3 seconds (%g).
                - SA(1.0) Pseudo-spectral acceleration at 1.0 seconds (%g).
                - SA(3.0) Pseudo-spectral acceleration at 3.0 seconds (%g).
    """

    if imcs is None:
        station_summary_imcs = DEFAULT_IMCS
    else:
        station_summary_imcs = imcs
    if imts is None:
        station_summary_imts = DEFAULT_IMTS
    else:
        station_summary_imts = imts

    subdfs = []
    for stream in streams:
        if not stream.passed:
            continue
        if len(stream) < 3:
            continue
        stream_summary = StationSummary.from_stream(
            stream, station_summary_imcs, station_summary_imts, event)
        summary = stream_summary.summary
        subdfs += [summary]
    dataframe = pd.concat(subdfs, axis=0).reset_index(drop=True)

    return dataframe
def test_rotd():
    ddir = os.path.join('data', 'testdata', 'process')
    datadir = pkg_resources.resource_filename('gmprocess', ddir)
    # Create a stream and station summary, convert from m/s^2 to cm/s^2 (GAL)
    osc1_data = np.genfromtxt(datadir + '/ALCTENE.UW..sac.acc.final.txt')
    osc2_data = np.genfromtxt(datadir + '/ALCTENN.UW..sac.acc.final.txt')
    osc1_data = osc1_data.T[1] * 100
    osc2_data = osc2_data.T[1] * 100
    tr1 = StationTrace(data=osc1_data, header={'channel': 'HN1', 'delta': 0.01,
                                        'npts': 24001, 'standard':
                                                {'corner_frequency': np.nan,
                                                    'station_name': '',
                                                    'source': 'json',
                                                    'instrument': '',
                                                    'instrument_period': np.nan,
                                                    'source_format': 'json',
                                                    'comments': '',
                                                    'source_file': '',
                                                    'structure_type': '',
                                                    'horizontal_orientation': np.nan,
                                                    'sensor_serial_number': '',
                                                    'process_level': 'raw counts',
                                                    'process_time': '',
                                                    'units': 'acc',
                                                    'instrument_damping': np.nan}})
    tr2 = StationTrace(data=osc2_data, header={'channel': 'HN2', 'delta': 0.01,
                                        'npts': 24001, 'standard':
                                                {'corner_frequency': np.nan,
                                                    'station_name': '',
                                                    'source': 'json',
                                                    'instrument': '',
                                                    'instrument_period': np.nan,
                                                    'source_format': 'json',
                                                    'comments': '',
                                                    'structure_type': '',
                                                    'source_file': '',
                                                    'horizontal_orientation': np.nan,
                                                    'sensor_serial_number': '',
                                                    'process_level': 'raw counts',
                                                    'process_time': '',
                                                    'units': 'acc',
                                                    'instrument_damping': np.nan}})
    st = StationStream([tr1, tr2])

    target_pga50 = 4.12528265306
    target_sa1050 = 10.7362857143
    target_pgv50 = 6.239364
    target_sa0350 = 10.1434159021
    target_sa3050 = 1.12614169215
    station = StationSummary.from_stream(st, ['rotd50'],
                                         ['pga', 'pgv', 'sa0.3', 'sa1.0', 'sa3.0'])

    pgms = station.pgms
    ROTD50 = pgms[pgms.IMC == 'ROTD(50.0)']
    pga = ROTD50[ROTD50.IMT == 'PGA'].Result.iloc[0]
    pgv = ROTD50[ROTD50.IMT == 'PGV'].Result.iloc[0]
    SA10 = ROTD50[ROTD50.IMT == 'SA(1.0)'].Result.iloc[0]
    SA03 = ROTD50[ROTD50.IMT == 'SA(0.3)'].Result.iloc[0]
    SA30 = ROTD50[ROTD50.IMT == 'SA(3.0)'].Result.iloc[0]
    np.testing.assert_allclose(pga, target_pga50, atol=0.1)
    np.testing.assert_allclose(SA10, target_sa1050, atol=0.1)
    np.testing.assert_allclose(pgv, target_pgv50, atol=0.1)
    np.testing.assert_allclose(SA03, target_sa0350, atol=0.1)
    np.testing.assert_allclose(SA30, target_sa3050, atol=0.1)