コード例 #1
0
ファイル: pgapgv.py プロジェクト: rizac/sod
def _sn_spectra(segment, config):
    """
    Computes the signal and noise spectra, as dict of strings mapped to tuples (x0, dx, y).
    Does not modify the segment's stream or traces in-place

    -Being decorated with '@gui.sideplot' or '@gui.customplot', this function must return
     a numeric sequence y taken at successive equally spaced points in any of these forms:
        - a Trace object
        - a Stream object
        - the tuple (x0, dx, y) or (x0, dx, y, label), where
            - x0 (numeric, `datetime` or `UTCDateTime`) is the abscissa of the first point
            - dx (numeric or `timedelta`) is the sampling period
            - y (numpy array or numeric list) are the sequence values
            - label (string, optional) is the sequence name to be displayed on the plot legend.
              (if x0 is numeric and `dx` is a `timedelta` object, then x0 will be converted
              to `UTCDateTime(x0)`; if x0 is a `datetime` or `UTCDateTime` object and `dx` is
              numeric, then `dx` will be converted to `timedelta(seconds=dx)`)
        - a dict of any of the above types, where the keys (string) will denote each sequence
          name to be displayed on the plot legend.

    :return: a dict with two keys, 'Signal' and 'Noise', mapped respectively to the tuples
    (f0, df, frequencies)

    :raise: an Exception if `segment.stream()` is empty or has more than one trace (possible
    gaps/overlaps)
    """
    arrival_time = UTCDateTime(segment.arrival_time) + config['sn_windows']['arrival_time_shift']
    strace, ntrace = sn_split(segment.stream()[0],  # assumes stream has only one trace
                              arrival_time, config['sn_windows']['signal_window'])
    x0_sig, df_sig, sig = _spectrum(strace, config)
    x0_noi, df_noi, noi = _spectrum(ntrace, config)
    return {'Signal': (x0_sig, df_sig, sig), 'Noise': (x0_noi, df_noi, noi)}
コード例 #2
0
ファイル: rungui.py プロジェクト: rizac/sdaas_eval
def signal_noise_spectra(segment, config):
    """
    Computes the signal and noise spectra, as dict of strings mapped to tuples (x0, dx, y).
    Does not modify the segment's stream or traces in-place

    :return: a dict with two keys, 'Signal' and 'Noise', mapped respectively to the tuples
    (f0, df, frequencies)

    :raise: an Exception if `segment.stream()` is empty or has more than one trace (possible
    gaps/overlaps)
    """
    o_trace = segment.stream()[0]
    trace = o_trace  # divide_sensitivity(o_trace, segment.inventory())
    # get sn windows: PLEASE NOTE!! sn_windows might calculate the cumulative of segment.stream(),
    # thus the latter should have been preprocessed (e.g. remove response, bandpass):
    arrival_time = UTCDateTime(
        segment.arrival_time) + config['sn_windows']['arrival_time_shift']
    signal_trace, noise_trace = sn_split(
        trace,  # assumes stream has only one trace
        arrival_time,
        config['sn_windows']['signal_window'])

    # compute psd values for both noise and signal:
    psd_n_x, psd_n_y = psd(noise_trace, segment.inventory())
    psd_s_x, psd_s_y = psd(signal_trace, segment.inventory())
    nlnm_x, nlnm_y = get_nlnm()
    nlnm_x, nlnm_y = nlnm_x[::-1], nlnm_y[::-1]
    nhnm_x, nhnm_y = get_nhnm()
    nhnm_x, nhnm_y = nhnm_x[::-1], nhnm_y[::-1]

    # sample at equally spaced periods. First get bounds:
    period_min = 2.0 / trace.stats.sampling_rate
    period_max = min(psd_n_x[-1] - psd_n_x[0], psd_s_x[-1] - psd_s_x[0])

    n_pts = config['num_psd_periods']  # 1024
    periods = np.linspace(period_min, period_max, n_pts, endpoint=True)
    psd_n_y = np.interp(np.log10(periods), np.log10(psd_n_x), psd_n_y)
    psd_s_y = np.interp(np.log10(periods), np.log10(psd_s_x), psd_s_y)
    nlnm_y = np.interp(np.log10(periods), np.log10(nlnm_x), nlnm_y)
    nhnm_y = np.interp(np.log10(periods), np.log10(nhnm_x), nhnm_y)

    x0, dx = periods[0], periods[1] - periods[0]

    return {
        'Signal': (x0, dx, psd_s_y),
        'Noise': (x0, dx, psd_n_y),
        'nlnm': (x0, dx, nlnm_y),
        'nhnm': (x0, dx, nhnm_y)
    }
コード例 #3
0
def signal_noise_spectra(segment, config):
    """
    Computes the signal and noise spectra, as dict of strings mapped to tuples (x0, dx, y).
    Does not modify the segment's stream or traces in-place

    :return: a dict with two keys, 'Signal' and 'Noise', mapped respectively to the tuples
    (f0, df, frequencies)

    :raise: an Exception if `segment.stream()` is empty or has more than one trace (possible
    gaps/overlaps)
    """
    # get sn windows: PLEASE NOTE!! sn_windows might calculate the cumulative of segment.stream(),
    # thus the latter should have been preprocessed (e.g. remove response, bandpass):
    arrival_time = UTCDateTime(
        segment.arrival_time) + config['sn_windows']['arrival_time_shift']
    signal_trace, noise_trace = sn_split(
        segment.stream()[0],  # assumes stream has only one trace
        arrival_time,
        config['sn_windows']['signal_window'])
    x0_sig, df_sig, sig = _spectrum(signal_trace, config)
    x0_noi, df_noi, noi = _spectrum(noise_trace, config)
    return {'Signal': (x0_sig, df_sig, sig), 'Noise': (x0_noi, df_noi, noi)}
コード例 #4
0
ファイル: core.py プロジェクト: lileipku00/stream2segment
    def exec_func(self, func, session, invcache, config):
        '''Executes the given function on the given segment identified by seg_id
           Returns the function result (or exception) after updating self, if needed.
           Raises if func raises
        '''
        seg_id = self.segment_id
        segment = getseg(session, seg_id)
        # if stream has not been loaded, do it now in order to pass a copy of it to
        # `func`: this prevents in-place modifications:
        stream = self.data.get('stream', None)
        if stream is None:
            try:
                stream = segment.stream()
            except Exception as exc:
                stream = exc
            self.data['stream'] = stream
        segment._stream = stream.copy() if isinstance(stream, Stream) else stream
        inventory = invcache.get(seg_id, None)
        segment.station._inventory = inventory

        try:
            return func(segment, config)
        finally:
            # set back values if needed, even if we had exceptions.
            # Any of these values might be also an exception. Call the
            # 'private' attribute cause the relative method, if exists, most likely raises
            # the exception, it does not return it
            sn_windows = self.data.get('sn_windows', None)
            if sn_windows is None:
                try:
                    if len(segment.stream()) != 1:
                        raise ValueError(("Unable to get sn-windows: %d traces in stream "
                                          "(possible gaps/overlaps)") % len(segment.stream()))
                    wndw = config['sn_windows']
                    arrival_time = \
                        UTCDateTime(segment.arrival_time) + wndw['arrival_time_shift']
                    self.data['sn_windows'] = sn_split(segment.stream()[0],
                                                       arrival_time,
                                                       wndw['signal_window'],
                                                       return_windows=True)
#                     self.data['sn_windows'] = segment.sn_windows(wndw['signal_window'],
#                                                                  wndw['arrival_time_shift'])
                except Exception as exc:
                    self.data['sn_windows'] = exc

            if inventory is None:
                invcache[segment] = segment.station._inventory  # might be exc, or None
            # reset segment stream to None, for safety: we do not know if it refers
            # to a pre-processed stream or not, and thus segment._stream needs to be set from
            # self.data each time we are here. Note that this should not be a problem as
            # the web app re-initializes the session each time (thus each segment SHOULD have
            # no _stream attribute), but for safety we remove it:
            segment._stream = None
            if not self.data.get('plot_title_prefix', None):
                title = None
                if isinstance(segment._stream, Stream):
                    title = segment._stream[0].get_id()
                    for trace in segment._stream:
                        if trace.get_id() != title:
                            title = None
                            break
                if title is None:
                    title = segment.seed_id
                if title is not None:
                    # try to get it from the stream. Otherwise, get it from the segment
                    self.data['plot_title_prefix'] = title