Пример #1
0
    def test_different_models(self):
        """
        Open all included models and make sure that they can produce
        reasonable travel times.
        """
        models = ["1066a", "1066b", "ak135", "herrin", "iasp91", "prem",
                  "sp6", "jb", "pwdk", "ak135f_no_mud"]
        for model in models:
            m = TauPyModel(model=model)

            # Get a p phase.
            arrivals = m.get_travel_times(
                source_depth_in_km=10.0, distance_in_degree=50.0,
                phase_list=["P"])
            # AK135 travel time.
            expected = 534.4
            self.assertTrue(abs(arrivals[0].time - expected) < 5)

            # Get an s phase.
            arrivals = m.get_travel_times(
                source_depth_in_km=10.0, distance_in_degree=50.0,
                phase_list=["S"])
            # AK135 travel time.
            expected = 965.1
            # Some models do produce s-waves but they are very far from the
            # AK135 value.
            self.assertTrue(abs(arrivals[0].time - expected) < 50)
Пример #2
0
def traveltime_first_arrival(source_depth_in_km, distance_in_degree, phase):

    # calculate the theoretical traveltime
    model = TauPyModel(model="ak135")

    if phase[0] in ["P", "p"]:
        arrivals = model.get_travel_times(
            source_depth_in_km=source_depth_in_km,
            distance_in_degree=distance_in_degree,
            phase_list=["Pg", "Pn", "P", "p"])
    elif phase[0] in ["S", "s"]:
        arrivals = model.get_travel_times(
            source_depth_in_km=source_depth_in_km,
            distance_in_degree=distance_in_degree,
            phase_list=["Sg", "Sn", "S", "s"])
    else:
        return -1.0

    if len(arrivals) < 1:
        print "no %sf arrivals available." % phase[0]
        t_pf = -1.0
        # name_pf = "-" % phase[0]
    else:
        tlst = []
        for arr in arrivals:
            tlst.append(arr.time)
        maxx = min(tlst)
        imax = tlst.index(maxx)

        arr = arrivals[imax]
        t_pf = arr.time
        # name_pf = arr.name

    return t_pf
Пример #3
0
    def test_different_models(self):
        """
        Open all included models and make sure that they can produce
        reasonable travel times.
        """
        models = ["1066a", "1066b", "ak135", "herrin", "iasp91", "prem",
                  "sp6", "jb", "pwdk", "ak135f_no_mud"]
        for model in models:
            m = TauPyModel(model=model)

            # Get a p phase.
            arrivals = m.get_travel_times(
                source_depth_in_km=10.0, distance_in_degree=50.0,
                phase_list=["P"])
            # AK135 travel time.
            expected = 534.4
            self.assertTrue(abs(arrivals[0].time - expected) < 5)

            # Get an s phase.
            arrivals = m.get_travel_times(
                source_depth_in_km=10.0, distance_in_degree=50.0,
                phase_list=["S"])
            # AK135 travel time.
            expected = 965.1
            # Some models do produce s-waves but they are very far from the
            # AK135 value.
            self.assertTrue(abs(arrivals[0].time - expected) < 50)
Пример #4
0
def cal_travel_time(evla, evlo, evdp, stla, stlo):

    # calculate distance for traveltime
    dist, az, baz = gps2dist_azimuth(evla, evlo, stla, stlo)

    # convert meter to km
    dist /= 1000.0
    gcarc = kilometer2degrees(dist)
    # print dist, az, baz, gcarc

    # calculate the theoretical traveltime
    model = TauPyModel(model="ak135")
    arrivals_pf = model.get_travel_times(source_depth_in_km=evdp,
                                         distance_in_degree=gcarc,
                                         phase_list=["Pg", "Pn", "P", "p"])
    arrivals_sf = model.get_travel_times(source_depth_in_km=evdp,
                                         distance_in_degree=gcarc,
                                         phase_list=["Sg", "Sn", "S", "s"])

    if len(arrivals_pf) < 1:
        print "no Pf arrivals available."
        t_pf = -12345.0
        name_pf = "-P"
    else:
        tlst = []
        for arr in arrivals_pf:
            tlst.append(arr.time)
        maxx = max(tlst)
        imax = tlst.index(maxx)

        arr = arrivals_pf[imax]
        t_pf = arr.time
        name_pf = arr.name
    # print arr.time, arr.name, arr.source_depth, arr.distance, gcarc

    if len(arrivals_sf) < 1:
        print "no Sf arrivals available."
        t_sf = -12345.0
        name_sf = "-S"
    else:
        tlst = []
        for arr in arrivals_sf:
            tlst.append(arr.time)
        maxx = max(tlst)
        imax = tlst.index(maxx)

        arr = arrivals_sf[imax]
        t_sf = arr.time
        name_sf = arr.name

    return dist, gcarc, az, baz, t_pf, name_pf, t_sf, name_sf
Пример #5
0
def get_traveltime(model: _TauPyModel,
                   phase: str,
                   depth: float,
                   distance: float,
                   take_off: bool = False) -> float:
    """
    Get travel time of phase
    :param model: Velocity model
    :param phases: list of phases to include in the inversion
    :param depth: Depth of event in km
    :param distance: Distance of event in degrees
    :param take_off: return take-off angle instead of traveltime
    """
    try:
        tt = model.get_travel_times(source_depth_in_km=depth,
                                    distance_in_degree=distance,
                                    phase_list=[phase])
        if take_off:
            return tt[0].takeoff_angle
        else:
            return tt[0].time
    except IndexError as e:
        # raise e("{} not arriving at {}km depth and {} degrees".format(phase, depth, distance))
        print("{} not arriving at {}km depth and {} degrees".format(
            phase, depth, distance))
        return None
Пример #6
0
def calculate_traveltime(src_depth):
    print("Calculate theorecial travel time")
    model = TauPyModel(model="prem")
    phases = [
        'P', 'PP', 'PcP', 'Pdiff', 'PKP', 'PKKP', 'S', 'SS', 'ScS', 'SSS',
        'Sdiff', 'SKS', 'SKKS'
    ]
    data = {}

    degrees = np.linspace(0, 180, 200)
    # Loop over all degrees.
    for degree in degrees:
        with warnings.catch_warnings(record=True):
            warnings.simplefilter('always')
            tt = model.get_travel_times(source_depth_in_km=src_depth,
                                        distance_in_degree=degree,
                                        phase_list=phases)
        # Mirror if necessary.
        for item in tt:
            phase = item.name
            if phase not in data:
                data[phase] = [[], []]
            data[phase][1].append(item.time)
            data[phase][0].append(degree)

    return data
Пример #7
0
def get_station_delays(station_coords,sources,velmod='PREM',phase_list=['s','S']):
    '''
    Given an array of station corodiantes and sources calculate the travel time
    from each source toe ach site.
    
    velmod is the FULL path to the .npz file used by TauPy
    '''
    
    from obspy.taup import TauPyModel
    from numpy import zeros
    from obspy.geodetics.base import locations2degrees

    model = TauPyModel(model=velmod)
    
    #Initalize output variabe
    delay_time=zeros((len(sources),len(station_coords)))
    
    #Loop over sources
    for ksource in range(len(sources)):
        
        print('Working on source %d of %d ' % (ksource,len(sources)))
        
        #loop over sites
        for ksite in range(len(station_coords)):
        
            distance_in_degrees=locations2degrees(station_coords[ksite,1],station_coords[ksite,0],
                                                      sources[ksource,2],sources[ksource,1])
            
            arrivals = model.get_travel_times(source_depth_in_km=sources[ksource,3],
                                  distance_in_degree=distance_in_degrees,phase_list=phase_list)
            
            delay_time[ksource,ksite]=arrivals[0].time
            
    return delay_time
Пример #8
0
def collect_data(filename):
    global events_coordinates, stations_coordinates

    station, event = station_event(filename)

    if stations_coordinates is None:
        stations_coordinates = _load_stations_coordinates(config.STATIONS_DATA)

    if events_coordinates is None:
        events_coordinates = _load_events_coordinates(config.EVENTS_DATA)

    if not event in events_coordinates:
        raise KeyError('Event %s not found in file "%s"' %
                       (event, config.EVENTS_DATA))

    if not station in stations_coordinates:
        raise KeyError('Station %s not found in file "%s"' %
                       (station, config.STATIONS_DATA))

    ev_lat, ev_lon, ev_time, ev_depth = events_coordinates[event]
    stat_lat, stat_lon = stations_coordinates[station]

    dist_m, azimuth, _ = gps2dist_azimuth(stat_lat, stat_lon, ev_lat, ev_lon)

    dist_deg = 180 * dist_m / (config.EARTH_RADIUS * math.pi)

    model = TauPyModel(model="iasp91")
    arr = model.get_travel_times(source_depth_in_km=ev_depth,
                                 distance_in_degree=dist_deg,
                                 phase_list=['P'])[0]

    slowness = arr.ray_param * 1000 / config.EARTH_RADIUS

    return azimuth, slowness
Пример #9
0
def phase_radiation_pattern(mt,
                            system='RTP',
                            phase_list=None,
                            source_depth_in_km=None,
                            distance_in_degree=None,
                            azimuth=None,
                            model='ak135'):
    '''Calcuate radiated amplitude of seismic phases

    >>> mt = [0.422, -0.689, 0.267, -0.432, -0.284, 0.377]
    >>> phase_radiation_pattern(mt, phase_list=['PcP', 'PKiKP'],
    ...                         source_depth_in_km=300, distance_in_degree=30,
    ...                         azimuth=50)
    [0.35494640676390243, 0.41287695358633075]
    '''

    from obspy.taup import TauPyModel

    model = TauPyModel(model=model)
    arrivals = model.get_travel_times(source_depth_in_km,
                                      distance_in_degree,
                                      phase_list=phase_list)

    mag_dict = {}
    for arrival in arrivals:
        mag = radiation_pattern(mt,
                                arrival.takeoff_angle,
                                azimuth,
                                wavetype=arrival.name[0],
                                system=system)
        mag_dict[arrival.name] = mag

    mag_list = [mag_dict[phasename] for phasename in phase_list]

    return mag_list
Пример #10
0
def test_add_data(ind=0):

    bng = test_add_event(ind)

    # Get travel time info
    tpmodel = TauPyModel(model='iasp91')

    # Get Travel times
    arrivals = tpmodel.get_travel_times(distance_in_degree=bng.meta.gac,
                                        source_depth_in_km=bng.meta.dep,
                                        phase_list=['P', 'PP'])

    # Get first P wave arrival among P and PP
    arrival = arrivals[0]

    # Attributes from parameters
    bng.meta.ttime = arrival.time
    bng.meta.phase = arrival.name

    # Get data
    t1 = arrival.time - 15.
    t2 = arrival.time + 15.
    has_data = bng.download_data(client=Client(),
                                 stdata=[],
                                 ndval=0.,
                                 new_sr=2.,
                                 t1=t1,
                                 t2=t2,
                                 returned=True,
                                 verbose=False)

    # assert has_data, 'No data'
    return has_data, bng
Пример #11
0
def phase_mask(tr_in, phase, **kwargs):
    '''
    return window around PKIKP phase
    '''
    tr = tr_in.copy()
    window_len = kwargs.get('window_len', 20)
    in_model = kwargs.get('model', 'prem50')

    if type(in_model) == str:
        model = TauPyModel(model=in_model)
    else:
        model = in_model

    tr.stats.distance = tr.stats.sac['gcarc']
    origin_time = tr.stats.sac['o']
    start = tr.stats.starttime

    sr = tr.stats.sampling_rate
    time = model.get_travel_times(source_depth_in_km=tr.stats.sac['evdp'],
                                  distance_in_degree=tr.stats.sac['gcarc'],
                                  phase_list=phase)
    t = time[0].time + origin_time
    window = tukey(int(sr * window_len), 0.2)
    mask = np.zeros(len(tr.data))
    mask[int(sr * t):int(sr * t) + int(sr * window_len)] = window
    tr.data *= mask
    return tr
Пример #12
0
def getPwaveArrival(depth, distance):
    ''' Routine to calculate phase arrivals 
        example:
        getPhaseInfo(600,60,"P",False)
    '''
    from obspy.taup import TauPyModel

    #specify earth model
    model = TauPyModel(model="iasp91")

    # the source - receiver distance in degrees
    #distance = 67.62
    #distance = 45
    #distance = 75.73
    # the source depth in km
    #depth = 500
    #depth = 37.5
    # list of phases you are interested in
    phaseList = ["P"]

    arrivals = model.get_travel_times(source_depth_in_km=depth,
                                      distance_in_degree=distance,
                                      phase_list=phaseList)

    # to get the travel time for a phase...
    arr = arrivals[0]
    pTime = arr.time
    print "The pwave arrives at: " + str(pTime)
    return pTime
Пример #13
0
def theoretical_arrival(tr, modelname="prem", phase_list=["P"]):
    """Get predicted phase arrival based the SAC trace 
    
    Parameter
    =========
    tr : obspy.trace
        obspy trace read from SAC file
    modelname : str
        model name
    phase_list : list
        phase list to get arrivals
    """
    # -------------------------------------------------------------------------
    # construct the origin time
    # -------------------------------------------------------------------------
    sactr = SACTrace.from_obspy_trace(tr)
    evdp, gcarc = sactr.evdp, sactr.gcarc

    # -------------------------------------------------------------------------
    # get waveforms of P and S wave based on given 1D model and time shift
    # -------------------------------------------------------------------------
    model = TauPyModel(model=modelname)
    arr = model.get_travel_times(source_depth_in_km = evdp / 1000, 
                                 distance_in_degree = gcarc, 
                                 phase_list=phase_list)
    return  sactr.reftime, arr
Пример #14
0
def arrivals(hypocenter, station_lon, station_lat):
    '''
    Get P and S arrival times
    '''

    from obspy.taup import TauPyModel
    from pyproj import Geod
    from numpy import rad2deg

    #Station to hypo distance
    g = Geod(ellps='WGS84')
    az, baz, dist = g.inv(hypocenter[0], hypocenter[1], station_lon,
                          station_lat)
    #Convert distance from m to degrees and km
    dist_deg = rad2deg(dist / 6371e3)
    print dist / 1000
    #Calculate theoretical arrivals
    mod = TauPyModel(model='Nocal')
    arrivals = mod.get_travel_times(source_depth_in_km=hypocenter[2],
                                    distance_in_degree=dist_deg,
                                    phase_list=('P', 'p', 'S', 's'))
    print arrivals

    #Parse arrivals
    ptime = 1e6
    stime = 1e6
    for k in range(len(arrivals)):
        if arrivals[k].name == 'p' or arrivals[k].name == 'P':
            ptime = min(arrivals[k].time, ptime)
        if arrivals[k].name == 's' or arrivals[k].name == 'S':
            stime = min(arrivals[k].time, stime)
    print ptime

    return ptime, stime
Пример #15
0
def ParrivalTime(Depthev, distangular):
    """calculate the P arrival time with the iasp91 model
    * inputs : 
        - Depthev :  depth of event in km
        - distangular :  distance angular between source and event in degrees
    * outputs : 
        - a :  P arrival time (P wave time travel between source and earthquake)
    * exemple :
    
        ParrivalTime(10,80)
        ==> 729.55308823 % 729 second from the source to arrive at the station
    """

    model = TauPyModel(model="taiwan_chietal2001")
    arrivals = model.get_travel_times(source_depth_in_km=Depthev,
                                      distance_in_degree=distangular,
                                      phase_list=["p", "s"])
    if len(arrivals) == 0:
        P = 0
        S = 0
    else:
        if len(arrivals) == 2:
            P = arrivals[0].time
            S = arrivals[1].time
        else:
            #if s not detected S will arrive a 25ms after the P wave
            P = arrivals[0].time
            S = arrivals[0].time + 0.5
    return P, S  #arrival of the P wave in second
Пример #16
0
def get_arrivals(st, model='ak135'):
    '''
    Returns complete arrival information for a particular stream and a theoretical velocity model ak135 or iasp91.
    
    Output is phase name, arrival time (in s after origin) and slowness (in s / km).
        
    Parameters
    ----------
    st : ObsPy Stream object
        Stream of SAC format seismograms for the seismic array
    model : string
        Model to use for the travel times, either 'ak135' or 'iasp91'.

    Returns
    -------
    phase_list : list
        List containing Phase objects containing the phase name, arrival time, and slowness of each arrival
    '''

    # Read event depth and great circle distance from SAC header
    depth = st[0].stats.sac.evdp
    delta = st[0].stats.sac.gcarc

    tau_model = TauPyModel(model)
    arrivals = tau_model.get_travel_times(depth, delta)
    
    phase_list = []
    
    for arrival in arrivals:
        phase = Phase(arrival.name, arrival.time, arrival.ray_param_sec_degree / G_KM_DEG)
        phase_list.append(phase)

    return phase_list
Пример #17
0
    def test_surface_wave_ttimes(self):
        """
        Tests the calculation of surface ttimes.

        Tested against a reference output from the Java TauP version.
        """
        for model, table in [("iasp91", "iasp91_surface_waves_table.txt"),
                             ("ak135", "ak135_surface_waves_table.txt")]:
            m = TauPyModel(model=model)
            filename = os.path.join(DATA, table)

            with open(filename, "rt") as fh:
                for line in fh:
                    _, distance, depth, phase, time, ray_param, _, _ \
                        = line.split()
                    distance, depth, time, ray_param = \
                        map(float, [distance, depth, time, ray_param])

                    arrivals = m.get_travel_times(
                        source_depth_in_km=depth, distance_in_degree=distance,
                        phase_list=[phase])

                    self.assertTrue(len(arrivals) > 0)

                    # Potentially multiple arrivals. Get the one closest in
                    # time and closest in ray parameter.
                    arrivals = sorted(
                        arrivals,
                        key=lambda x: (abs(x.time - time),
                                       abs(x.ray_param_sec_degree -
                                           ray_param)))
                    arrival = arrivals[0]
                    self.assertEqual(round(arrival.time, 2), round(time, 2))
                    self.assertEqual(round(arrival.ray_param_sec_degree, 2),
                                     round(ray_param, 2))
Пример #18
0
def get_first_arrival(st, model='ak135'):
    '''
    Returns first arrival information for a particular stream and a theoretical velocity model ak135 or iasp91.
    
    Output is phase name, arrival time (in s after origin) and slowness (in s / km).
        
    Parameters
    ----------
    st : ObsPy Stream object
        Stream of SAC format seismograms for the seismic array
    model : string
        Model to use for the travel times, either 'ak135' or 'iasp91'.

    Returns
    -------
    phase : Phase object
        Phase object containing the phase name, arrival time, and slowness of the first arrival
    '''

    # Read event depth and great circle distance from SAC header
    depth = st[0].stats.sac.evdp
    delta = st[0].stats.sac.gcarc

    taup = TauPyModel(model)
    first_arrival = taup.get_travel_times(depth, delta)[0]

    phase = Phase(first_arrival.name, first_arrival.time, first_arrival.ray_param_sec_degree / G_KM_DEG)

    return phase
Пример #19
0
    def get_P(self, epi, depth_m):
        model = TauPyModel(model=self.veloc_model)
        tt = model.get_travel_times(source_depth_in_km=depth_m / 1000,
                                    distance_in_degree=epi,
                                    phase_list=['P'])

        return tt[0].time
Пример #20
0
def predictArrivalTimes(st, lslat, lslon):
    """
    Uses 1D Earth model TauPyModel to predict how long it took for S waves 
    generated by landslide to reach each station.
    INPUT
    st - obspy stream object with seismic data
    lslat (float) - latitudinal coordinate of landslide (make negative for south
        of Equator)
    lslon (float) - longitudinal coordinate of landslide (make negative for west
        of Prime Meridian)
    OUTPUT
    pred_arrival_secs (list of floats) - arrival times of event at each 
        station (going away from the landslide) based on obspy TauPyModel in s
        after landslide time
    """

    # With taup function
    model = TauPyModel(model="iasp91")
    pred_arrival_secs = []  # List of datetime objects

    # Get distance in degrees from landslide to each station
    # Use distance to find arrival time at each station using TauPyModel
    for trace in st:
        stationlat = trace.stats.coordinates['latitude']
        stationlon = trace.stats.coordinates['longitude']
        ddeg = calcCoordDistance(lslat, lslon, stationlat, stationlon)[1]

        arrival = model.get_travel_times(source_depth_in_km=0.0,
                                         distance_in_degree=ddeg,
                                         phase_list=["S"])
        # Check if other arrival times besides first might be better?
        pred_arrival_secs.append(arrival[0].time)

    return (pred_arrival_secs)
Пример #21
0
def get_arrivals(st, model='ak135'):
    '''
    Returns complete arrival information for a particular stream and a theoretical velocity model ak135 or iasp91.
    
    Output is phase name, arrival time (in s after origin) and slowness (in s / km).
        
    Parameters
    ----------
    st : ObsPy Stream object
        Stream of SAC format seismograms for the seismic array
    model : string
        Model to use for the travel times, either 'ak135' or 'iasp91'.

    Returns
    -------
    phase_list : list
        List containing Phase objects containing the phase name, arrival time, and slowness of each arrival
    '''

    # Read event depth and great circle distance from SAC header
    depth = st[0].stats.sac.evdp
    delta = st[0].stats.sac.gcarc

    tau_model = TauPyModel(model)
    arrivals = tau_model.get_travel_times(depth, delta)

    phase_list = []

    for arrival in arrivals:
        phase = Phase(arrival.name, arrival.time,
                      arrival.ray_param_sec_degree / G_KM_DEG)
        phase_list.append(phase)

    return phase_list
Пример #22
0
def get_first_arrival(st, model='ak135'):
    '''
    Returns first arrival information for a particular stream and a theoretical velocity model ak135 or iasp91.
    
    Output is phase name, arrival time (in s after origin) and slowness (in s / km).
        
    Parameters
    ----------
    st : ObsPy Stream object
        Stream of SAC format seismograms for the seismic array
    model : string
        Model to use for the travel times, either 'ak135' or 'iasp91'.

    Returns
    -------
    phase : Phase object
        Phase object containing the phase name, arrival time, and slowness of the first arrival
    '''

    # Read event depth and great circle distance from SAC header
    depth = st[0].stats.sac.evdp
    delta = st[0].stats.sac.gcarc

    taup = TauPyModel(model)
    first_arrival = taup.get_travel_times(depth, delta)[0]

    phase = Phase(first_arrival.name, first_arrival.time,
                  first_arrival.ray_param_sec_degree / G_KM_DEG)

    return phase
Пример #23
0
def est_p_time(depth,dist,ot):

        model = TauPyModel(model='iasp91')
        arrival = model.get_travel_times(source_depth_in_km=depth,
                                           distance_in_degree=dist,phase_list=['p','P'])
        p_arrival = ot + arrival[0].time
        return p_arrival
Пример #24
0
def getPhaseInfo(depth, distance, phaseList, plotFlag):
    ''' Routine to calculate phase arrivals 
        example:
        getPhaseInfo(600,60,"P",False)
    '''
    from obspy.taup import TauPyModel

    #specify earth model
    model = TauPyModel(model="iasp91")

    # the source - receiver distance in degrees
    #distance = 67.62
    #distance = 45
    #distance = 75.73
    # the source depth in km
    #depth = 500
    #depth = 37.5
    # list of phases you are interested in
    #phaseList = ["P", "S", "PKiKP"]

    arrivals = model.get_travel_times(source_depth_in_km=depth,
                                      distance_in_degree=distance,
                                      phase_list=phaseList)

    # to get the travel time for a phase...
    arr = arrivals[0]
    pTime = arr.time
    print "The pwave arrives at: " + str(pTime)

    # if  you want to plot the raypaths... this is totally cool!
    if plotFlag:
        arrivals = model.get_ray_paths(source_depth_in_km=depth,
                                       distance_in_degree=distance)

        arrivals.plot()
Пример #25
0
def test_get_travel_time_df():
    datapath = os.path.join("data", "testdata", "travel_times")
    datadir = pkg_resources.resource_filename("gmprocess", datapath)

    sc1 = StreamCollection.from_directory(os.path.join(datadir, "ci37218996"))
    sc2 = StreamCollection.from_directory(os.path.join(datadir, "ci38461735"))
    scs = [sc1, sc2]

    df1, catalog = create_travel_time_dataframe(
        sc1, os.path.join(datadir, "catalog_test_traveltimes.csv"), 5, 0.1,
        "iasp91")
    df2, catalog = create_travel_time_dataframe(
        sc2, os.path.join(datadir, "catalog_test_traveltimes.csv"), 5, 0.1,
        "iasp91")

    model = TauPyModel("iasp91")
    for dfidx, df in enumerate([df1, df2]):
        for staidx, sta in enumerate(df):
            for eqidx, time in enumerate(df[sta]):
                sta_coords = scs[dfidx][staidx][0].stats.coordinates
                event = catalog[eqidx]
                dist = locations2degrees(
                    sta_coords["latitude"],
                    sta_coords["longitude"],
                    event.latitude,
                    event.longitude,
                )
                if event.depth_km < 0:
                    depth = 0
                else:
                    depth = event.depth_km
                travel_time = model.get_travel_times(depth, dist,
                                                     ["p", "P", "Pn"])[0].time
                abs_time = event.time + travel_time
                np.testing.assert_almost_equal(abs_time, time, decimal=1)
Пример #26
0
    def test_surface_wave_ttimes(self):
        """
        Tests the calculation of surface ttimes.

        Tested against a reference output from the Java TauP version.
        """
        for model, table in [("iasp91", "iasp91_surface_waves_table.txt"),
                             ("ak135", "ak135_surface_waves_table.txt")]:
            m = TauPyModel(model=model)
            filename = os.path.join(DATA, table)

            with open(filename, "rt") as fh:
                for line in fh:
                    _, distance, depth, phase, time, ray_param, _, _ \
                        = line.split()
                    distance, depth, time, ray_param = \
                        map(float, [distance, depth, time, ray_param])

                    arrivals = m.get_travel_times(
                        source_depth_in_km=depth, distance_in_degree=distance,
                        phase_list=[phase])

                    self.assertTrue(len(arrivals) > 0)

                    # Potentially multiple arrivals. Get the one closest in
                    # time and closest in ray parameter.
                    arrivals = sorted(
                        arrivals,
                        key=lambda x: (abs(x.time - time),
                                       abs(x.ray_param_sec_degree -
                                           ray_param)))
                    arrival = arrivals[0]
                    self.assertEqual(round(arrival.time, 2), round(time, 2))
                    self.assertEqual(round(arrival.ray_param_sec_degree, 2),
                                     round(ray_param, 2))
Пример #27
0
 def get_S(self, epi, depth_m):
     model = TauPyModel(model=self.veloc_model)
     tt = model.get_travel_times(source_depth_in_km=depth_m / 1000,
                                 distance_in_degree=epi,
                                 phase_list=['S'])
     tt = tt[0].time + self.global_S_shift
     return tt
Пример #28
0
def main():
                                      #           MAIN PROGRAM BODY
    OT,stlat,stlon,evlat,evlon,depth = getoptions()
    origin_time = UTCDateTime(str(OT))
    result = client.distaz(stalat=stlat, stalon=stlon, evtlat=evlat,evtlon=evlon)
    model = TauPyModel(model="AK135")
    arrivals = model.get_travel_times(source_depth_in_km=depth,distance_in_degree=result['distance'])#,
                                     #phase_list = ['P','PcP','PP','PKiKP','S','SS','ScS','SKiKS'])
    print "Distance = {0:.1f} arc degrees.".format(result['distance'])
    print "{0:.0f} Km distance.".format(result['distance']*111.25)
    print "{0:.0f} deg back Azimuth.".format(result['backazimuth'])
    table = client.traveltime(evloc=(evlat,evlon),staloc=[(stlat,stlon)],evdepth=depth)
    print "Selected phase list:\n"
    print (table.decode())

                   #   Print the phases, travel time and forecasted arrival time.
    phasename = []
    phasetime = []
    arrivaltime = []
    print "For origin time {}, ".format(origin_time)
    print "TauP big list of phases and arrival times:"
    for i in range(0,len(arrivals)):
        phasename.append(arrivals[i].name)
        phasetime.append(arrivals[i].time)
        at = origin_time+(arrivals[i].time)
        arrivaltime.append(at)
        print 'Phase: {0} \t arrives in {1:.2f} sec. at time {2:02.0f}:{3:02.0f}:{4:02.0f}.{5:02.0f}' \
              .format(arrivals[i].name,arrivals[i].time,at.hour,at.minute,at.second,at.microsecond/10000)
    arrivalpaths = model.get_ray_paths(source_depth_in_km=depth,distance_in_degree=result['distance'])#,\
                                #        phase_list = ['P','PcP','PP','PKiKP','S','SS','ScS','SKiKS'])
    arrivalpaths.plot()
Пример #29
0
 def _get_origtime_delays(self,
                          vel_mod,
                          target_depth,
                          max_dist=1.,
                          num_vals=20):
     """
     :param max_dist: maximum distance (degrees) at which to calculate
     :param num_vals: number of distances (from 0 to max_distance) at
         which to calculate delats
     :returns: dict with keys 'op' and 'ps' corresponding to sorted lists 
         of delay times from origin-to-p and p-to-s
     """
     try:
         model = TauPyModel(model=vel_mod)
     except Exception:
         build_taup_model(vel_mod)  # converts from np or tvel to npz
         model = TauModel.from_file(vel_mod)  # reads npz
     delays = {'op': [0], 'ps': [0]}
     # ps_delays, p_delays = [0], [0]
     step = max_dist / num_vals
     for distance in np.arange(step, max_dist + .001, step):
         arrivals = model.get_travel_times(target_depth,
                                           distance,
                                           phase_list=["P", "S"])
         p_delay = [x.time for x in arrivals if x.phase == "P"]
         s_delay = [x.time for x in arrivals if x.phase == "S"]
         ps_delay = s_delay - p_delay
         if len(ps_delay) == 1 and len(p_delay) == 1:
             delays['ps'].append(ps_delay[0])
             delays['op'].append(p_delay[0])
         else:
             log(
                 'Could not calculate delays for dist={:.2g} degrees'.
                 format(distance), 'warning')
     return delays
Пример #30
0
def extract_tectonics(df, stations, pre, pos, outpath, label, latitude,
                      longitude):
    model = TauPyModel(model='iasp91')

    for date, df in tectonic.iterate_days(df):
        date = UTCDateTime(date)
        st = Stream()
        for station in stations:
            for channel in ['HHE', 'HHN', 'HHZ']:
                filepath = DB_MSEED_PATH_FMT.format(waves_path=WAVES_PATH,
                                                    year=date.year,
                                                    julday=date.julday,
                                                    station=station,
                                                    channel=channel)
                if path.isfile(filepath):
                    st += read(filepath)

        for i, row in df.iterrows():
            print(row.time)
            source_depth_in_km = row.depth
            if source_depth_in_km < 0:
                source_depth_in_km = 0

            distance_in_degree = locations2degrees(row.latitude, row.longitude,
                                                   latitude, longitude)

            arrivals = model.get_travel_times(
                source_depth_in_km=source_depth_in_km,
                distance_in_degree=distance_in_degree,
                phase_list=['p', 's', 'P', 'S', 'Pdiff', 'Sdiff'])

            origin_time = UTCDateTime(row.time)

            for arrival in arrivals:
                if arrival.name in ['p', 'P', 'Pdiff']:
                    p = origin_time + arrival.time

            for arrival in arrivals:
                if arrival.name in ['s', 'S', 'Sdiff']:
                    s = origin_time + arrival.time

            starttime = p - pre
            endtime = s + pos

            _st = st.slice(starttime=starttime, endtime=endtime)
            if len(_st) > 0:
                msd_outpath = path.join(
                    outpath, MSD_FNAME_FMT.format(**st_to_fname(label, _st)))
                _st.write(msd_outpath, format='MSEED')

            d = dict(longitude=row.longitude,
                     latitude=row.latitude,
                     depth=row.depth,
                     magnitude=row.magnitude,
                     time=row.time)

            jsn_outpath = path.join(
                outpath, JSN_FNAME_FMT.format(**st_to_fname(label, _st)))
            with open(jsn_outpath, 'w') as f:
                json.dump(d, f, indent=4)
Пример #31
0
def test_get_travel_time_df():
    datapath = os.path.join('data', 'testdata', 'travel_times')
    datadir = pkg_resources.resource_filename('gmprocess', datapath)

    sc1 = StreamCollection.from_directory(os.path.join(datadir, 'ci37218996'))
    sc2 = StreamCollection.from_directory(os.path.join(datadir, 'ci38461735'))
    scs = [sc1, sc2]

    df1, catalog = create_travel_time_dataframe(
        sc1, os.path.join(datadir, 'catalog_test_traveltimes.csv'), 5, 0.1,
        'iasp91')
    df2, catalog = create_travel_time_dataframe(
        sc2, os.path.join(datadir, 'catalog_test_traveltimes.csv'), 5, 0.1,
        'iasp91')

    model = TauPyModel('iasp91')
    for dfidx, df in enumerate([df1, df2]):
        for staidx, sta in enumerate(df):
            for eqidx, time in enumerate(df[sta]):
                sta_coords = scs[dfidx][staidx][0].stats.coordinates
                event = catalog[eqidx]
                dist = locations2degrees(sta_coords['latitude'],
                                         sta_coords['longitude'],
                                         event.latitude, event.longitude)
                if event.depth_km < 0:
                    depth = 0
                else:
                    depth = event.depth_km
                travel_time = model.get_travel_times(depth, dist,
                                                     ['p', 'P', 'Pn'])[0].time
                abs_time = event.time + travel_time
                np.testing.assert_almost_equal(abs_time, time, decimal=1)
Пример #32
0
 def test_earth_models(self):
     for earth_model_name in ["prem", "ak135f_no_mud", "1066a"]:
         earthmodel = TauPyModel(model=earth_model_name)
         for source_depth in [12, 50, 200]:
             model_data = self.gen_test_model(earth_model_name)
             test_model = SeisModel(model_data,
                                    flattening=True,
                                    use_kappa=False)
             test_source = SourceModel(sdep=source_depth, srcType="dc")
             receiver_distance = [1, 10, 50]
             test_config = Config(model=test_model,
                                  source=test_source,
                                  receiver_distance=receiver_distance,
                                  degrees=True)
             t0_list, _, _, _ = taup(
                 test_config.src_layer, test_config.rcv_layer,
                 test_config.model.th.astype(np.float64),
                 test_config.model.vp.astype(np.float64),
                 test_config.receiver_distance.astype(np.float64))
             for index, each_distance in enumerate(receiver_distance):
                 arrivals = earthmodel.get_travel_times(
                     source_depth_in_km=source_depth,
                     distance_in_degree=each_distance,
                     phase_list=["p", "P"])
                 assert np.allclose(arrivals[0].time,
                                    t0_list[index],
                                    rtol=0.01)
Пример #33
0
   def migrate(self,plot=False):
      import geopy
      from geopy.distance import VincentyDistance

      '''
      This is a rewritten function that combines the functions find_pierce_coor and
      migrate_1d so that it's more efficient.  Still in testing stages. RM 2/6/16
      '''

      depth_range = np.arange(50,800,5)        #set range of pierce points
      value       = np.zeros((len(depth_range)))

      #geodetic info
      bearing     = self.az
      lon_s = self.ses3d_seismogram.sy
      lat_s = 90.0-self.ses3d_seismogram.sx
      lon_r = self.ses3d_seismogram.ry
      lat_r = 90.0-self.ses3d_seismogram.rx
      origin      = geopy.Point(lat_s, lon_s)

      #find how far away the pierce point is
      model  = TauPyModel(model='pyrolite_5km')

      for i in range(0,len(depth_range)):
         phase = 'P'+str(depth_range[i])+'s'
         pierce = model.get_pierce_points(self.eq_depth,self.delta_deg,phase_list=[phase])
         tt     = model.get_travel_times(self.eq_depth,self.delta_deg,phase_list=['P',phase])

         #in case there's duplicate phase arrivals
         for j in range(0,len(tt)):
            if tt[j].name == 'P':
               p_arr = tt[j].time           
            elif tt[j].name == phase:
               phase_arr = tt[j].time

         #determine value 
         Pds_time = phase_arr - p_arr
         i_start  = int((0.0 - self.window_start)/self.ses3d_seismogram.dt)
         i_t      = int(Pds_time/self.ses3d_seismogram.dt) + i_start
         value[i] = self.prf[i_t]

         points = pierce[0].pierce
         for j in range(0,len(points)):
            if points[j]['depth'] == depth_range[i] and points[j]['dist']*(180.0/np.pi) > 20.0:
               prc_dist = points[j]['dist']*(180.0/np.pi)
               d_km = prc_dist * ((2*np.pi*6371.0/360.0))
               destination = VincentyDistance(kilometers=d_km).destination(origin,bearing)
               lat = destination[0]
               lon = destination[1]
               row = {'depth':depth_range[i],'dist':prc_dist,'lat':lat,'lon':lon,'value':value[i]}
               self.pierce_dict.append(row)

      if plot == True:
         plt.plot(value,depth_range)
         plt.gca().invert_yaxis()
         plt.show()

      return value,depth_range
def plot_raw(rawdir, tcollection, event):
    """Make PNG plots of a collection of raw waveforms.

    Args:
        rawdir (str):
            Directory where PNG files should be saved.
        tcollection (StreamCollection):
            Sequence of streams.
        event (ScalarEvent):
            Event object.

    """
    model = TauPyModel(model="iasp91")
    source_depth = event.depth_km
    if source_depth < 0:
        source_depth = 0
    eqlat = event.latitude
    eqlon = event.longitude
    for stream in tcollection:
        stlat = stream[0].stats.coordinates['latitude']
        stlon = stream[0].stats.coordinates['longitude']
        dist = float(locations2degrees(eqlat, eqlon, stlat, stlon))
        try:
            arrivals = model.get_travel_times(source_depth_in_km=source_depth,
                                              distance_in_degree=dist,
                                              phase_list=['P', 'p', 'Pn'])
            arrival = arrivals[0]
            arrival_time = arrival.time
        except BaseException as e:
            fmt = ('Exception "%s" generated by get_travel_times() dist=%.3f '
                   'depth=%.1f')
            logging.warning(fmt % (str(e), dist, source_depth))
            arrival_time = 0.0
        ptime = arrival_time + (event.time - stream[0].stats.starttime)
        outfile = os.path.join(rawdir, '%s.png' % stream.get_id())

        fig, axeslist = plt.subplots(nrows=3, ncols=1, figsize=(12, 6))
        for ax, trace in zip(axeslist, stream):
            ax.plot(trace.times(), trace.data, color='k')
            ax.set_xlabel('seconds since start of trace')
            ax.set_title('')
            ax.axvline(ptime, color='r')
            ax.set_xlim(left=0, right=trace.times()[-1])
            legstr = '%s.%s.%s.%s' % (trace.stats.network, trace.stats.station,
                                      trace.stats.location,
                                      trace.stats.channel)
            ax.legend(labels=[legstr], frameon=True, loc='upper left')
            tbefore = event.time + arrival_time < trace.stats.starttime + 1.0
            tafter = event.time + arrival_time > trace.stats.endtime - 1.0
            if tbefore or tafter:
                legstr = 'P arrival time %.1f seconds' % ptime
                left, right = ax.get_xlim()
                xloc = left + (right - left) / 20
                bottom, top = ax.get_ylim()
                yloc = bottom + (top - bottom) / 10
                ax.text(xloc, yloc, legstr, color='r')
        plt.savefig(outfile, bbox_inches='tight')
        plt.close()
Пример #35
0
    def getArrivals(self, phases=["SKS"]):
        """
		Generates predicted arrival times using a whole earth velocity model

		Parameters
		----------
		phases : list of strings, optional
			List containing the seismic phases for which to calculate 
			predicted traveltimes. Defaults to "SKS"

		"""
        model = TauPyModel(model="ak135")

        rows_list = []
        for i, receiver in self.network.receivers.iterrows():
            rec = psm.Receiver(receiver)
            tmp_df = self.src_df[self.src_df['otime'].between(
                rec.deployment, rec.retrieval)]

            for j, source in tmp_df.iterrows():
                src = psm.Source(source)
                tmp_dist = locations2degrees(src.latitude, src.longitude,
                                             rec.latitude, rec.longitude)
                phase_arr = model.get_travel_times(
                    source_depth_in_km=src.depth,
                    distance_in_degree=tmp_dist,
                    phase_list=phases,
                    receiver_depth_in_km=rec.elevation / 1000)

                if not phase_arr:
                    continue
                else:
                    phase_dict = {}
                    for k in range(len(phase_arr)):
                        key = phase_arr[k].purist_name
                        time = phase_arr[k].time

                        if key in phase_dict:
                            phase_dict[key].append(phase_arr[k].time)
                        else:
                            phase_dict[key] = []
                            phase_dict[key].append(time)

                            dict1 = {
                                "sourceid": src.sourceid,
                                "receiverid": rec.station,
                                "traveltime": phase_dict,
                                "waveform?": False
                            }
                            print(dict1)
                            rows_list.append(dict1)

        self.arr_df = pd.DataFrame(rows_list, columns=self.arr_cols)
        self.arr_df.to_csv(self.arr_file, index=False)

        available_receivers = self.network.filterReceivers(self.arr_df)
        available_receivers.to_csv(self.rec_file, index=False)
Пример #36
0
def cal_s_arrival(wave, setting):
    model = TauPyModel(model=setting["model"])
    depth = float(wave.stats.sac.evdp)
    gcarc = float(wave.stats.sac.gcarc)
    s_obj = model.get_travel_times(source_depth_in_km=depth,
                                   distance_in_degree=gcarc,
                                   phase_list=["s"])
    if (s_obj == []):
        S_obj = model.get_travel_times(source_depth_in_km=depth,
                                       distance_in_degree=gcarc,
                                       phase_list=["S"])
        # return S_obj[0].time
        return wave.stats.starttime + timedelta(
            seconds=(float(wave.stats.sac.o) + S_obj[0].time))
    else:
        # return s_obj[0].time
        return wave.stats.starttime + timedelta(
            seconds=(float(wave.stats.sac.o) + s_obj[0].time))
Пример #37
0
def get_traveltime(stlon, stlat, eqlon, eqlat, eqdep, model_name='iasp91'):
    #c=Client()
    #c=c.distaz(stalat=stlat,stalon=stlon,evtlat=eqlat,evtlon=eqlon)
    #dist,az,baz=obspy.geodetics.base.gps2dist_azimuth(lat1=evlat,lon1=evlon,lat2=stlat,lon2=stlon)
    dist_degree = obspy.geodetics.locations2degrees(lat1=eqlat,
                                                    long1=eqlon,
                                                    lat2=stlat,
                                                    long2=stlon)
    model = TauPyModel(model=model_name)
    P = model.get_travel_times(source_depth_in_km=eqdep,
                               distance_in_degree=dist_degree,
                               phase_list=('P', 'p'),
                               receiver_depth_in_km=0)
    S = model.get_travel_times(source_depth_in_km=eqdep,
                               distance_in_degree=dist_degree,
                               phase_list=('S', 's'),
                               receiver_depth_in_km=0)
    return (P[0].time, S[0].time, dist_degree)
Пример #38
0
 def test_p_ak135(self):
     """
     Test P phase arrival against TauP output in in model AK135.
     """
     m = TauPyModel(model="ak135")
     arrivals = m.get_travel_times(source_depth_in_km=10.0,
                                   distance_in_degree=35.0,
                                   phase_list=["P"])
     self._compare_arrivals_with_file(
         arrivals, "taup_time_-h_10_-ph_ttall_-deg_35_-mod_ak135")
Пример #39
0
    def test_buried_receiver(self):
        """
        Simple test for a buried receiver.
        """
        m = TauPyModel(model="iasp91")
        arrivals = m.get_travel_times(
            source_depth_in_km=10.0, distance_in_degree=90.0,
            receiver_depth_in_km=50,
            phase_list=["P", "PP", "S"])

        self._compare_arrivals_with_file(arrivals, "buried_receivers.txt")
Пример #40
0
 def test_ak135(self):
     """
     Test travel times for lots of phases against output from TauP in model
     AK135.
     """
     m = TauPyModel(model="ak135")
     arrivals = m.get_travel_times(source_depth_in_km=10.0,
                                   distance_in_degree=35.0,
                                   phase_list=["ttall"])
     self._compare_arrivals_with_file(
         arrivals, "taup_time_-h_10_-ph_ttall_-deg_35_-mod_ak135")
Пример #41
0
 def test_p_pwdk(self):
     """
     Test P phase arrival against TauP output in model pwdk
     with different cache values to test `TauModel.load_from_depth_cache`
     """
     for cache in self.caches:
         m = TauPyModel(model="pwdk", cache=cache)
         arrivals = m.get_travel_times(source_depth_in_km=10.0,
                                       distance_in_degree=35.0,
                                       phase_list=["P"])
         self._compare_arrivals_with_file(
             arrivals, "taup_time_-h_10_-ph_P_-deg_35_-mod_pwdk")
Пример #42
0
def zero_phase(tr,phase,rf_window=[-10,120],**kwargs):
##############################################################################
   '''
   Finds predicted PP arrival and zeros a window centered on the arrival
   args--------------------------------------------------------------------------
   tr: obspy trace
   phase: phase to zero
   time_start: starting point of receiver function time window

   kwargs---------------------------------------------------------------------
   window_half_dur : half duration of zero window (default = 2.5 s)
   taup_model
   '''
   window_half_dur = kwargs.get('window_half_dur',2.5)
   taup_model = kwargs.get('taup_model','none')
   if taup_model == 'none':
      taup_model = TauPyModel('prem')

   arrs = taup_model.get_travel_times(source_depth_in_km=tr.stats.evdp,
                                      distance_in_degree=tr.stats.gcarc,
                                      phase_list=['P',phase])
   print 'arrs = ', arrs
   P_arr  = 'none'
   phase_arr = 'none'

   for arr in arrs:
      if arr.name == 'P':
         P_arr = arr
      elif arr.name == phase:
         phase_arr = arr

   if P_arr == 'none' or phase_arr == 'none':
      raise ValueError('problem occured in function "zero_phase", no matching arrivals found')
   else:
      P_time = P_arr.time
      phase_time = phase_arr.time
      delay_time = phase_time - P_time
      zero_window_center = -1.0*rf_window[0] + delay_time
      zero_window_start  = zero_window_center - window_half_dur
      zero_window_end    = zero_window_center + window_half_dur
      zero_window_start_index = int(zero_window_start/tr.stats.delta)
      zero_window_end_index   = int(zero_window_end/tr.stats.delta)

      #case 1: entire window is in range
      if zero_window_start_index >= 0 and zero_window_end_index <= len(tr.data):
         tr.data[zero_window_start_index:zero_window_end_index] = 0.0
      #case 2: end of window is out of range
      if zero_window_start_index >= 0 and zero_window_end_index >= len(tr.data):
         tr.data[zero_window_start_index:] = 0.0
      #case 3: entire window is out of range
      if zero_window_start_index >= len(tr.data):
         print "PP arrives outside the receiver function window"
Пример #43
0
 def test_ak135(self):
     """
     Test travel times for lots of phases against output from TauP in model
     AK135 with different cache values to test
     `TauModel.load_from_depth_cache`
     """
     for cache in self.caches:
         m = TauPyModel(model="ak135", cache=cache)
         arrivals = m.get_travel_times(source_depth_in_km=10.0,
                                       distance_in_degree=35.0,
                                       phase_list=["ttall"])
         self._compare_arrivals_with_file(
             arrivals, "taup_time_-h_10_-ph_ttall_-deg_35_-mod_ak135")
Пример #44
0
def get_time_correction(traces, source_dict):
    from obspy.taup import TauPyModel
    model = TauPyModel(model="iasp91")
    from obspy.core.util import locations2degrees
    time_correction = []
    for trace in traces:
        name = trace.stats.station
        lat_inline = source_dict[name][4]
        lon_inline = source_dict[name][3]
        lat = trace.stats.sac.stla
        lon = trace.stats.sac.stlo
        evla = trace.stats.sac.evla
        evlo = trace.stats.sac.evlo
        evdp = trace.stats.sac.evdp
        dist_inline = locations2degrees(lat_inline, lon_inline, evla, evlo)
        dist = locations2degrees(lat, lon, evla, evlo)

        time_inline = model.get_travel_times(source_depth_in_km=evdp/1000.0, distance_in_degree=dist_inline, phase_list=["P"])[0].time
        time = model.get_travel_times(source_depth_in_km=evdp/1000.0, distance_in_degree=dist, phase_list=["P"])[0].time
        time_correction.append(time - time_inline)
        # print time_inline - time
    return time_correction
Пример #45
0
    def test_underside_reflections(self):
        """
        Tests the calculation of a couple of underside reflection phases.
        """
        m = TauPyModel(model="iasp91")
        # If an interface that is not in the model is used for a phase name,
        # it should snap to the next closest interface. This is reflected in
        # the purist name of the arrivals.
        arrivals = m.get_travel_times(
            source_depth_in_km=10.0, distance_in_degree=90.0,
            phase_list=["P", "PP", "P^410P", "P^660P", "P^300P", "P^400P",
                        "P^500P", "P^600P"])

        self._compare_arrivals_with_file(arrivals, "underside_reflections.txt")
Пример #46
0
def plot_expected_arrivals(source_depth, distance, ref_model, phase_list, seislist):
###############################################################################
   '''
   Plot expected arrival times based on seismic reference model ref_model
   ref_model must be a string. source depth in km. distance in degrees.
   phase_list is list of phase names you want to plot. seis is a numpy array for 
   a seismic trace.
   See obpy taup manual
   '''

   model = TauPyModel(model=ref_model)
   arrivals = model.get_travel_times(source_depth_in_km=source_depth, \
           distance_in_degree=distance)

   seis_number = len(seislist)
   #seis = seislist
   #seis_array = np.loadtxt(seis) 
   #max_value = seis_array[:,1].max()

   arrive_list = str(arrivals).strip().split('\n')
   arrive_array = [ii.split() for ii in arrive_list]
   phase_dict = dict()
   for ii in range(1,len(arrive_array)):
      phase_dict[arrive_array[ii][0]] = float(arrive_array[ii][4])

   print 'Phases Available: \n'
   print phase_dict.keys()

   for jj in range(0,len(seislist)):
      plt.subplot(seis_number,1,(jj+1))
      seis_array = np.loadtxt(seislist[jj])
      max_value = seis_array[:,1].max()*0.9

      #Remove y lables
      ax = plt.gca()
      ax.set_yticklabels([])
      #Label plot
      plt.title(seislist[jj])
      plt.xlabel('Seconds')
      #change limits
      plt.xlim(seis_array[0,0],seis_array[len(seis_array)-1,0])
      
      for ii in phase_list:
         plt.axvline(x=phase_dict[ii], ymin=-1.0, ymax = 1.0, \
                linewidth=2, color='gold')
         plt.text(phase_dict[ii],max_value,ii)
         plt.text(0,max_value,'Vel. model '+ref_model)
      plt.plot(seis_array[:,0],seis_array[:,1])

   plt.show()
Пример #47
0
def pds_time(evdp,gcarc,depth,model_1d):
##################################################################################
   '''
   Calculates the travel time of a Pds phase based on the spherical travel time 
   equation (e.g., Eager et al. 2010)

   args--------------------------------------------------------------------------
   evdp:event depth 
   gcarc:great circle distance
   depth:the conversion depth
   model_1d:velocity model 
   '''
   taup_model = TauPyModel(model_1d)
   p_arrs = taup_model.get_travel_times(evdp,gcarc,['P'])
Пример #48
0
def get_travel_times(station, earthquake):
    """
    Calculate travel times for phases using obspy.

    Return a dictionary with phase name as key and arrival time as the value.
    """
    dist = locations2degrees(station[0], station[1],
                             earthquake[0], earthquake[1])
    model = TauPyModel(model='iasp91')
    arrivals = model.get_travel_times(source_depth_in_km=earthquake[2],
                                      distance_in_degree=dist)
    travel_times = {}
    for arrival in arrivals:
        travel_times[arrival.name] = arrival.time
    return travel_times
Пример #49
0
    def exclude_by_local_catalog(self,catalogue):

        model = TauPyModel(model="iasp91")
        
        for tr in self.stream:
            tr.detrend('demean')


        t_total = 0.0
        for trace in self.stream:
            t_total += trace.stats.npts
            
            
        for event in catalogue:
            # get origin time
            t0 = event.origins[0].time
            lon0 = event.origins[0].longitude
            lat0 = event.origins[0].latitude
            depth0 = event.origins[0].depth/1000.
            coords = self.inv.get_coordinates(self.ids[0])
            data_start = self.stream[0].stats.starttime
            if t0 < data_start-24*60*60.:
                continue
            data_end = self.stream[-1].stats.endtime
            if t0 > data_end:
                continue
            dist = gps2dist_azimuth(lat0,lon0,
                    coords["latitude"],coords["longitude"])[0]/1000.
            p_arrival = model.get_travel_times(source_depth_in_km=depth0,
                                  distance_in_degree=dist/111.19,phase_list=["P"])
            if len(p_arrival)==0:
                tcut1 = t0
            else:
                tcut1 = t0 + p_arrival[0].time - 10.0 #10s before p arrival
            if tcut1<t0:
                tcut1 = t0
            tcut2 = t0 + dist/1.0 + 60. #slowest surface-wave arrival plus one minute
            self.stream.cutout(starttime=tcut1,endtime=tcut2)


        t_kept = 0.0
        for trace in self.stream:
            t_kept += trace.stats.npts
        

        print('* Excluded all events in local catalogue.', file=self.ofid)
        print('* Lost %g percent of original traces' %((t_total-t_kept)/t_total*100), file=self.ofid)
        return()
Пример #50
0
    def test_javaPnPs(self):
        """
        Test for Pn Ps waves bug, 53797854298c6ee9dcbf3398bbec3bdd12def964

        Reference output generated by::

          $ ./taup_time -mod iasp91 -ph P,S,PP,PPP,PPPP,S,SS,SS,SSSS,Sn,Pn \
              -h 15 -deg 10
        """
        m = TauPyModel(model="iasp91")
        ph = "P,S,PP,PPP,PPPP,S,SS,SS,SSSS,Sn,Pn".split(",")
        arrivals = m.get_travel_times(source_depth_in_km=15.0,
                                      distance_in_degree=10.0,
                                      phase_list=ph)
        self._compare_arrivals_with_file(arrivals,
                                         "java_tauptime_pnsn")
Пример #51
0
    def slowness_correct(self,tr,phase_list):
        '''Functions that corrects the slowness of the incoming P wave from a
        teleseismic earthquake to vertical incidence.
        '''
        # Calculate the slowness of the incoming P wave given station and
        # source locations
        # Calculate distance between source and receiver
        distance = locations2degrees(tr.stats.sac.evla,
                                     tr.stats.sac.evlo,
                                     tr.stats.sac.stla,
                                     tr.stats.sac.stlo)
        # Initialise the earth model
        model = TauPyModel(model="ak135")
        # Get the slowness
        arrivals = model.get_travel_times(tr.stats.sac.evdp/1000,
                                          distance,phase_list=phase_list)
        slowness = arrivals[0].ray_param*(np.pi/19980) # s/rad to s/km

        # Create an array of the uncorrected reflection times of the trace
        rtimes = np.linspace(0,650,tr.stats.npts)
        # Loop over the reflection times to calculate the corrected reflection
        # time
        corr_rtimes = []
        for rtime in tr.times():
            # Calculate appropriate correction velocity
            if rtime <= 5.0:
                v0 = 4.0
            elif rtime <= 13.0 and rtime > 5.0:
                v0 = 6.0
            else:
                v0 = 8.0
            # Correct the reflection time
            #v0 = 6.0
            corr_rtimes.append(rtime/(1.0-(0.5*(v0**2.0)*slowness**2.0)))

        # Interpolate the rtimes to smooth out sampling rates changes
        #times = np.interp(tr.data,corr_rtimes,tr.data)
        #f = interp1d(tr.data, corr_rtimes)
        #rtimes = f(tr.data)

        # Calculate end point and gap between the new rtimes
        gap = corr_rtimes[1] - corr_rtimes[0]

        # Create a trace with times corresponding to the new rtimes
        tr.stats.sampling_rate = 1.0/gap

        return tr
Пример #52
0
    def proto_slowness_correct(self):
        '''Legacy function that uses ak135 to correct for the slowness of the 
        incoming P wave using the evenmt location.
        '''
        # Initialise ak135 model for calculating average velocities at depth
        model = TauPyModel(model="ak135")
        
        # First create a model of average velocities that correspond to certain
        # two way arrival times for calculating correction velocity

        # Create a list for storing travel times
        t_times = []
        depths = []
        # Loop over different source depths
        for depth in np.arange(1,700,5):
            try:
                arrivals = model.get_travel_times(source_depth_in_km=depth,
                           distance_in_degree=0.0,
                           phase_list=['p'])
                depths.append(depth)
            except TypeError:
                continue
            twt_time = (arrivals[0].time)*2.0
            t_times.append(twt_time)

        # COnvert the depths to average velocities from the ak135 model
        # Load in ak135
        '''
        Reading in the vel model is going wrong, write script to test what the
        output looks like
        '''
        vel_model = np.loadtxt("telecorr/ak135.txt")
        # Loop over the modelled depths, locate the nearest depth in ak135, and
        # calculate the average velocity above it
        aver_vel = [] # EMpty array for storing average velocities
        for depth in depths:
            # Over modelled depths
            for k, mod_depth in enumerate(vel_model[:][0]):
                if mod_depth >= depth:
                    aver_vel.append(np.mean(vel_model[:k][1]))

        vel_table = [t_times,aver_vel] # Create a look up table
        print vel_table

        return vel_table
Пример #53
0
    def test_p_iasp91_manual(self):
        """
        Manual test for P phase in IASP91.
        """
        m = TauPyModel(model="iasp91")
        arrivals = m.get_travel_times(source_depth_in_km=10.0,
                                      distance_in_degree=35.0,
                                      phase_list=["P"])
        self.assertEqual(len(arrivals), 1)
        p_arrival = arrivals[0]

        self.assertEqual(p_arrival.name, "P")
        self.assertAlmostEqual(p_arrival.time, 412.43, 2)
        self.assertAlmostEqual(p_arrival.ray_param_sec_degree, 8.612, 3)
        self.assertAlmostEqual(p_arrival.takeoff_angle, 26.74, 2)
        self.assertAlmostEqual(p_arrival.incident_angle, 26.69, 2)
        self.assertAlmostEqual(p_arrival.purist_distance, 35.00, 2)
        self.assertEqual(p_arrival.purist_name, "P")
Пример #54
0
   def migrate_1d(self,window_start=-10.0,window_end=100.0,plot='True'):
      '''
      migrate receiver functions to depth using a 1d model
      '''
      eq_depth = self.ses3d_seismogram.sz/1000.0
      dist     = self.delta_deg
      
      #depth interval
      d_start  = 50.0
      d_end    = 800.0
      dz       = 5 

      #taup model
      model = TauPyModel(model='pyrolite_5km')
      depth = np.arange(d_start,d_end,dz)
      #depth = depth[::-1]
      value = np.zeros((len(depth)))

      for i in range(0,len(depth)):
         phase    = 'P'+str(depth[i])+'s' 
         tt       = model.get_travel_times(eq_depth,dist,phase_list=['P',phase])

         for j in range(0,len(tt)):
            if tt[j].name == 'P':
               time_p = tt[j].time
            elif tt[j].name == phase:
               time_phase = tt[j].time

         time = time_phase - time_p 
         i_start  = int((0.0 - window_start)/self.ses3d_seismogram.dt)
         i_t      = int(time/self.ses3d_seismogram.dt) + i_start
         value[i] = -1.0*self.prf[i_t]
         self.pierce_dict[i]['value'] = self.prf[i_t]

      if plot == 'True':
         plt.plot(value,depth)
         plt.gca().invert_yaxis()
         plt.show()

      return value,depth
def pick_travel(stream, origin, picker_config=None):
    '''Use TauP travel time model to find P-Phase arrival time.

    Args:
        stream (StationStream):
            StationStream containing 1 or more channels of waveforms.
        origin (ScalarEvent):
            Event origin/magnitude information.
        picker_config (dict):
            Dictionary containing picker configuration.
    Returns:
        tuple:
            - Best estimate for p-wave arrival time (s since start of trace).
            - Mean signal to noise ratio based on the pick.
    '''
    if picker_config is None:
        picker_config = get_config(section='pickers')
    model = picker_config['travel_time']['model']
    model = TauPyModel(model=model)
    if stream[0].stats.starttime == NAN_TIME:
        return (-1, 0)
    lat = origin.latitude
    lon = origin.longitude
    depth = origin.depth_km
    etime = origin.time
    slat = stream[0].stats.coordinates.latitude
    slon = stream[0].stats.coordinates.longitude

    dist_deg = locations2degrees(lat, lon, slat, slon)
    arrivals = model.get_travel_times(source_depth_in_km=int(depth),
                                      distance_in_degree=dist_deg,
                                      phase_list=['P', 'p', 'Pn'])
    if not len(arrivals):
        return (-1, 0)
    arrival = arrivals[0]
    minloc = arrival.time + (etime - stream[0].stats.starttime)
    mean_snr = calc_snr(stream, minloc)
    return (minloc, mean_snr)
Пример #56
0
def calculate_traveltime(src_depth):
    print("Calculate theorecial travel time")
    model = TauPyModel(model="prem")
    phases = ['P', 'PP', 'PcP', 'Pdiff', 'PKP', 'PKKP',
              'S', 'SS', 'ScS', 'SSS', 'Sdiff', 'SKS', 'SKKS']
    data = {}

    degrees = np.linspace(0, 180, 200)
    # Loop over all degrees.
    for degree in degrees:
        with warnings.catch_warnings(record=True):
            warnings.simplefilter('always')
            tt = model.get_travel_times(source_depth_in_km=src_depth,
                                        distance_in_degree=degree,
                                        phase_list=phases)
        # Mirror if necessary.
        for item in tt:
            phase = item.name
            if phase not in data:
                data[phase] = [[], []]
            data[phase][1].append(item.time)
            data[phase][0].append(degree)

    return data
Пример #57
0
def data_request(client_name, cat_client_name, start, end, minmag, net=None, scode="*", channels="*", minlat=None,
                 maxlat=None,minlon=None,maxlon=None, station_minlat=None,
                 station_maxlat=None, station_minlon=None, station_maxlon=None, mindepth=None, maxdepth=None, 
                 radialcenterlat=None, radialcenterlon=None, minrad=None, maxrad=None,
                 station_radialcenterlat=None, station_radialcenterlon=None, station_minrad=None, station_maxrad=None,
                 azimuth=None, baz=False, t_before_first_arrival=1, t_after_first_arrival=9, savefile=False, file_format='SAC'):
	"""
	Searches in a given Database for seismic data. Restrictions in terms of starttime, endtime, network etc can be made.
	If data is found it returns a stream variable, with the waveforms, an inventory with all station and network information
	and a catalog with the event information.

	:param client_name: Name of desired fdsn client, for a list of all clients see: 
		                https://docs.obspy.org/tutorial/code_snippets/retrieving_data_from_datacenters.html
	:type  client_name:  string

	:param cat_client_name: Name of Event catalog

	:type  cat_client_name: string

	:param start, end: starttime, endtime
	:type : UTCDateTime

	:param minmag: Minimum magnitude of event
	:type  minmag: float

	:param net: Network code for which to search data for
	:type  net: string

	:param scode: Station code for which to search data for
	:type  scode: string

	:param channels: Used channels of stations 
	:type  channels: string

	:param minlat, maxlat, minlon, maxlon: Coordinate-window of interest
	:type : float

	:param mindepth, maxdepth: depth information of event in km
	:type : float

	:param radialcenterlat, radialcenterlon: Centercoordinates of a radialsearch, if radialsearch=True
	:type : float

	:param minrad, maxrad: Minimum and maximum radii for radialsearch
	:type : float

	:param azimuth: Desired range of azimuths of event, station couples in deg as a list [minimum azimuth, maximum azimuth]
	:type  azimuth: list

	:param baz: Desired range of back-azimuths of event, station couples in deg as a list [minimum back azimuth, maximum back azimuth]
	:type  baz: list

	:param t_before_first_arrival, t_before_after_arrival: Length of the seismograms, startingpoint, minutes before 1st arrival and
															minutes after 1st arrival.
	:type  t_before_first_arrival, t_before_after_arrival: float, int
	
	:param savefile: if True, Stream, Inventory and Catalog will be saved local, in the current directory.
	:type  savefile: bool

	:param format: File-format of the data, for supported formats see: https://docs.obspy.org/packages/autogen/obspy.core.stream.Stream.write.html#obspy.core.stream.Stream.write
	:type  format: string
	
	returns

	:param: list_of_stream, Inventory, Catalog
	:type: list, obspy, obspy 



	### Example 1 ###

	from obspy import UTCDateTime
	from sipy.util.data_request import data_request

	start = UTCDateTime(2010,1,1,0,0)
	end = UTCDateTime(2010,12,31,0,0)
	minmag = 8
	station = '034A'
	list_of_stream, inventory, cat = data_request('IRIS', start, end, minmag, net='TA', scode=station)
	
	st = list_of_stream[0]
	st = st.select(channel='BHZ')
	st.normalize()
	inv = inventory[0]

	st.plot()
	inv.plot()
	cat.plot()

	### Example 2 ###

	from obspy import UTCDateTime
	from sipy.util.data_request import data_request

	start = UTCDateTime(2010,1,1,0,0)
	end = UTCDateTime(2010,12,31,0,0)
	minmag = 8
	station = '034A'
	client = 'IRIS'
	cat_client = 'globalcmt'
	list_of_stream, inventory, cat = data_request(client, cat_client, start, end, minmag, net='TA', scode=station)
	
	st = list_of_stream[0]
	st = st.select(channel='BHZ')
	st.normalize()
	inv = inventory[0]

	st.plot()
	inv.plot()
	cat.plot()

	"""

	data =[]
	stream = Stream()
	streamall = []
	

	#build in different approach for catalog search, using urllib

	if cat_client_name == 'globalcmt':
		catalog = request_gcmt(starttime=start, endtime=end, minmagnitude=minmag, mindepth=mindepth, maxdepth=maxdepth, minlatitude=minlat, maxlatitude=maxlat, minlongitude=minlon, maxlongitude=maxlon)
		client = Client(client_name)
	else:	
		client = Client(client_name)
		try:
			catalog = client.get_events(starttime=start, endtime=end, minmagnitude=minmag, mindepth=mindepth, maxdepth=maxdepth, latitude=radialcenterlat, longitude=radialcenterlon, minradius=minrad, maxradius=maxrad,minlatitude=minlat, maxlatitude=maxlat, minlongitude=minlon, maxlongitude=maxlon)

		except:
			print("No events found for given parameters.")
			return

	print("Following events found: \n")
	print(catalog)
	m = TauPyModel(model="ak135")
	Plist = ["P", "Pdiff", "p"]
	for event in catalog:
		print("\n")
		print("########################################")
		print("Looking for available data for event: \n")
		print(event.short_str())
		print("\n")

		origin_t = event.origins[0].time
		station_stime = UTCDateTime(origin_t - 3600*24)
		station_etime = UTCDateTime(origin_t + 3600*24)

		try:
			inventory = client.get_stations(network=net, station=scode, level="station", starttime=station_stime, endtime=station_etime,
			 								minlatitude=station_minlat, maxlatitude=station_maxlat, minlongitude=station_minlon, maxlongitude=station_maxlon,
			 								latitude=station_radialcenterlat, longitude=station_radialcenterlon, minradius=station_minrad, maxradius=station_maxrad)
			print("Inventory found.")
		except:
			print("No Inventory found for given parameters")
			return
		
		for network in inventory:

			elat = event.origins[0].latitude
			elon = event.origins[0].longitude
			depth = event.origins[0].depth/1000.

			array_fits = True
			if azimuth or baz:
				cog=center_of_gravity(network)
				slat = cog['latitude']
				slon = cog['longitude']			
				epidist = locations2degrees(slat,slon,elat,elon)
				arrivaltime = m.get_travel_times(source_depth_in_km=depth, distance_in_degree=epidist,
							                        phase_list=Plist)

				P_arrival_time = arrivaltime[0]

				Ptime = P_arrival_time.time
				tstart = UTCDateTime(event.origins[0].time + Ptime - t_before_first_arrival * 60)
				tend = UTCDateTime(event.origins[0].time + Ptime + t_after_first_arrival * 60)


				center = geometrical_center(inv)
				clat = center['latitude']
				clon = center['longitude']
				if azimuth:
					print("Looking for events in the azimuth range of %f to %f" % (azimuth[0], azimuth[1]) )
					center_az = gps2dist_azimuth(clat, clon, elat, elon)[1]
					if center_az > azimuth[1] and center_az < azimuth[0]: 
						print("Geometrical center of Array out of azimuth bounds, \ncheking if single stations fit")
						array_fits = False

				elif baz:
					print("Looking for events in the back azimuth range of %f to %f" %(baz[0], baz[1]))
					center_baz = gps2dist_azimuth(clat, clon, elat, elon)[2]
					if center_baz > baz[1] and center_baz < baz[0]: 
						print("Geometrical center of Array out of back azimuth bounds, \ncheking if single stations fit")
						array_fits = False

			# If array fits to azimuth/back azimuth or no azimuth/back azimuth is given
			no_of_stations = 0
			if array_fits:

				for station in network:

					epidist = locations2degrees(station.latitude,station.longitude,elat,elon)
					arrivaltime = m.get_travel_times(source_depth_in_km=depth, distance_in_degree=epidist,
								                        phase_list=Plist)

					P_arrival_time = arrivaltime[0]

					Ptime = P_arrival_time.time
					tstart = UTCDateTime(event.origins[0].time + Ptime - t_before_first_arrival * 60)
					tend = UTCDateTime(event.origins[0].time + Ptime + t_after_first_arrival * 60)

					try:
						streamreq = client.get_waveforms(network=network.code, station=station.code, location='*', channel=channels, starttime=tstart, endtime=tend, attach_response=True)
						no_of_stations += 1
						print("Downloaded data for %i of %i available stations!" % (no_of_stations, network.selected_number_of_stations), end='\r' )
						sys.stdout.flush()
						stream 		   += streamreq
						try:
							if inventory_used:
								inventory_used 	+= client.get_stations(network=net, station=scode, level="station", starttime=station_stime, endtime=station_etime,
			 								minlatitude=station_minlat, maxlatitude=station_maxlat, minlongitude=station_minlon, maxlongitude=station_maxlon,
			 								latitude=station_radialcenterlat, longitude=station_radialcenterlon, minradius=station_minrad, maxradius=station_maxrad)
									
						except:
								inventory_used 	 = client.get_stations(network=net, station=scode, level="station", starttime=station_stime, endtime=station_etime,
			 								minlatitude=station_minlat, maxlatitude=station_maxlat, minlongitude=station_minlon, maxlongitude=station_maxlon,
			 								latitude=station_radialcenterlat, longitude=station_radialcenterlon, minradius=station_minrad, maxradius=station_maxrad)
					except:
						continue


			# If not checking each station individually.
			else:
				for station in network:
					epidist = locations2degrees(station.latitude,station.longitude,elat,elon)
					arrivaltime = m.get_travel_times(source_depth_in_km=depth, distance_in_degree=epidist,
								                        phase_list=Plist)


					P_arrival_time = arrivaltime[0]

					Ptime = P_arrival_time.time
					tstart = UTCDateTime(event.origins[0].time + Ptime - t_before_first_arrival * 60)
					tend = UTCDateTime(event.origins[0].time + Ptime + t_after_first_arrival * 60)

					fit = False
					if azimuth:
						stat_az = gps2dist_azimuth(station.latitude, station.longitude, elat, elon)[1]
						if stat_az > azimuth[1] and stat_az < azimuth[0]: fit = True
					elif baz:
						stat_baz = gps2dist_azimuth(station.latitude, station.longitude, elat, elon)[2]
						if stat_baz > baz[1] and stat_baz < baz[0]: fit = True
					if fit:
						try:
							streamreq = client.get_waveforms(network = network.code, station = station.code, location='*', channel = channels, startime = tstart, endtime = tend, attach_response = True)
							no_of_stations += 1
							print("Downloaded data for %i of %i available stations!" % (no_of_stations, network.selected_number_of_stations), end='\r' )
							sys.stdout.flush()
							stream 		+= streamreq
							try:
								if inventory_used:
									inventory_used 	+= client.get_stations(network=net, station=scode, level="station", starttime=station_stime, endtime=station_etime,
			 								minlatitude=station_minlat, maxlatitude=station_maxlat, minlongitude=station_minlon, maxlongitude=station_maxlon,
			 								latitude=station_radialcenterlat, longitude=station_radialcenterlon, minradius=station_minrad, maxradius=station_maxrad)
							except:
									inventory_used 	 = client.get_stations(network=net, station=scode, level="station", starttime=station_stime, endtime=station_etime,
			 								minlatitude=station_minlat, maxlatitude=station_maxlat, minlongitude=station_minlon, maxlongitude=station_maxlon,
			 								latitude=station_radialcenterlat, longitude=station_radialcenterlon, minradius=station_minrad, maxradius=station_maxrad)
						except:

							continue

		try:
			if invall:
				invall += inventory
		except:
			invall 		= inventory

		attach_network_to_traces(stream, inventory)
		attach_coordinates_to_traces(stream, inventory, event)
		streamall.append(stream)
		stream = Stream()

	if savefile:
		stname = str(origin_t).split('.')[0] + ".MSEED"
		invname = stname + "_inv.xml"
		catname = stname + "_cat.xml"
		stream.write(stname, format=file_format)
		inventory.write(invname, format="STATIONXML")
		catalog.write(catname, format="QUAKEML")

	plt.ion()
	#invall.plot()
	#catalog.plot()
	plt.ioff()
	inventory = invall
	list_of_stream = streamall
	return(list_of_stream, inventory, catalog)
Пример #58
0
    def test_vs_java_iasp91(self):
        """
        Tests the traveltime calculation against the output from TauP in the
        file 'java_tauptime_testoutput'.

        Essentially tests all kinds of depths and epicentral distances in the
        model iasp91.
        """
        m = TauPyModel(model="iasp91")
        filename = os.path.join(DATA, "java_tauptime_testoutput")

        expected = collections.defaultdict(list)
        all_phases = []

        with open(filename, "rt") as fh:
            for line in fh:
                line = line.strip()
                if not line or line.startswith("----"):
                    continue
                line = line.replace("=", "")
                line = line.split()
                try:
                    float(line[0])
                except:
                    continue
                expected[(float(line[0]), float(line[1]))].append({
                    "distance": float(line[0]),
                    "depth": float(line[1]),
                    "name": line[2],
                    "time": float(line[3]),
                    "ray_param_sec_degree": float(line[4]),
                    "takeoff_angle": float(line[5]),
                    "incident_angle": float(line[6]),
                    "purist_distance": float(line[7]),
                    "purist_name": line[8]})
                all_phases.append(line[2])

        all_phases = sorted(set(all_phases))

        for key, value in expected.items():
            expected[key] = sorted(value,
                                   key=lambda x: (x["time"],
                                                  x["ray_param_sec_degree"],
                                                  x["name"]))
        actual_phases = []
        for dist, depth in expected.keys():
            tt = m.get_travel_times(source_depth_in_km=depth,
                                    distance_in_degree=dist,
                                    phase_list=all_phases)
            tt = sorted(tt, key=lambda x: (
                round(x.time, 2),
                round(x.ray_param_sec_degree, 3),
                x.name))
            expected_arrivals = expected[(dist, depth)]

            for actual_arrival, expected_arrival in zip(tt, expected_arrivals):
                self._assert_arrivals_equal(actual_arrival, expected_arrival)
            for arr in tt:
                actual_phases.append(arr.name)
        actual_phases = sorted(set(actual_phases))
        self.assertEqual(actual_phases, all_phases)
Пример #59
0
def dump_picks(event_log,vel_model,gf_list,out_file):
    '''  
    Dump P and S picks to a file
    '''
    
    from obspy.taup import TauPyModel
    from obspy.geodetics.base import gps2dist_azimuth
    from obspy.geodetics import locations2degrees
    from numpy import genfromtxt,zeros,array,ones
    from string import replace
    
    
    #Read station locations
    sta=genfromtxt(gf_list,usecols=0,dtype='S')
    lonlat=genfromtxt(gf_list,usecols=[1,2])
    
    #Load velocity model for ray tracing
    velmod = TauPyModel(vel_model)
    
    # Get hypocenter
    f=open(event_log,'r')
    loop_go=True
    while loop_go:
        line=f.readline()
        if 'Hypocenter (lon,lat,z[km])' in line:
            s=replace(line.split(':')[-1],'(','')
            s=replace(s,')','')
            hypo=array(s.split(',')).astype('float')
            loop_go=False

    #compute station to hypo distances
    d=zeros(len(lonlat))
    for k in range(len(lonlat)):
        d[k],az,baz=gps2dist_azimuth(lonlat[k,1],lonlat[k,0],hypo[1],hypo[0])
        d[k]=d[k]/1000
        

    f=open(out_file,'w')
    f.write('# sta,lon,lat,ptime(s),stime(s)\n')
    
    for k in range(len(sta)):
        
        
        # Ray trace
        deg=locations2degrees(hypo[1],hypo[0],lonlat[k,1],lonlat[k,0])
        try:
            arrivals = velmod.get_travel_times(source_depth_in_km=hypo[2],distance_in_degree=deg,phase_list=['P','Pn','S','Sn','p','s'])
        except:
            arrivals = velmod.get_travel_times(source_depth_in_km=hypo[2]-1.056,distance_in_degree=deg,phase_list=['P','Pn','S','Sn','p','s'])

        ptime=1e6
        stime=1e6
            
        #Determine P and S arrivals
        for kphase in range(len(arrivals)):
            if 'P' == arrivals[kphase].name or 'p' == arrivals[kphase].name or 'Pn' == arrivals[kphase].name:
                if arrivals[kphase].time<ptime:
                    ptime=arrivals[kphase].time
            if 'S' == arrivals[kphase].name or 's' == arrivals[kphase].name or 'Sn' == arrivals[kphase].name:
                if arrivals[kphase].time<stime:
                    stime=arrivals[kphase].time
            
        lon=lonlat[k,0]
        lat=lonlat[k,1] 
        station=sta[k]       
        line='%s\t%.4f\t%.4f\t%10.4f\t%10.4f\n' % (station,lon,lat,ptime,stime)
        f.write(line)
        
    f.close()
Пример #60
0
    def test_vs_java_iasp91(self):
        """
        Tests the traveltime calculation against the output from TauP in the
        file 'java_tauptime_testoutput'.

        Essentially tests all kinds of depths and epicentral distances in the
        model iasp91.

        Test data generated with:

          $ phases="P,p,PcP,PcS,Pdiff,PKIKKIKP,PKIKKIKS,PKIKP,PKiKP,PKIKPPKIKP"
          $ phases="${phases},PKIKS,PKKP,PKKS,PKP,PKPPKP,PP,pP,pPdiff,pPKIKP"
          $ phases="${phases},pPKiKP,pPKP,PS,pS,pSKIKS,pSKS,S,s,ScP,ScS,Sdiff"
          $ phases="${phases},SKIKKIKP,SKIKKIKS,SKIKP,SKiKP,SKIKS,SKIKSSKIKS"
          $ phases="${phases},SKKP,SKKS,SKS,SKSSKS,SP,sP,sPdiff,sPKIKP,sPKiKP"
          $ phases="${phases},sPKP,SS,sS,sSdiff,sSKIKS,sSKS"

          $ for dist in 0 45 90 180 160; do
              for depth in 0 100 1000 2889; do
                ./taup_time -mod iasp91 -ph ${phases} -h ${depth} -deg ${dist}
              done
            done
        """
        m = TauPyModel(model="iasp91")
        filename = os.path.join(DATA, "java_tauptime_testoutput")

        expected = collections.defaultdict(list)
        all_phases = []

        with open(filename, "rt") as fh:
            for line in fh:
                line = line.strip()
                if not line or line.startswith("----"):
                    continue
                line = line.replace("=", "")
                line = line.split()
                try:
                    float(line[0])
                except:
                    continue
                expected[(float(line[0]), float(line[1]))].append({
                    "distance": float(line[0]),
                    "depth": float(line[1]),
                    "name": line[2],
                    "time": float(line[3]),
                    "ray_param_sec_degree": float(line[4]),
                    "takeoff_angle": float(line[5]),
                    "incident_angle": float(line[6]),
                    "purist_distance": float(line[7]),
                    "purist_name": line[8]})
                all_phases.append(line[2])

        all_phases = sorted(set(all_phases))

        for key, value in expected.items():
            expected[key] = sorted(value,
                                   key=lambda x: (x["time"],
                                                  x["ray_param_sec_degree"],
                                                  x["name"]))
        actual_phases = []
        for dist, depth in expected.keys():
            tt = m.get_travel_times(source_depth_in_km=depth,
                                    distance_in_degree=dist,
                                    phase_list=all_phases)
            tt = sorted(tt, key=lambda x: (
                round(x.time, 2),
                round(x.ray_param_sec_degree, 3),
                x.name))
            expected_arrivals = expected[(dist, depth)]

            for actual_arrival, expected_arrival in zip(tt, expected_arrivals):
                self._assert_arrivals_equal(actual_arrival, expected_arrival)
            for arr in tt:
                actual_phases.append(arr.name)
        actual_phases = sorted(set(actual_phases))
        self.assertEqual(actual_phases, all_phases)