示例#1
0
def geoproject(lat_p, lon_p, lat1, lon1, lat2, lon2):
    azi = distaz(lat1, lon1, lat2, lon2).baz
    dis_center = distaz(lat1, lon1, lat_p, lon_p).delta
    azi_center = distaz(lat1, lon1, lat_p, lon_p).baz
    dis_along = atand(tand(dis_center))*cosd(azi-azi_center)
    (lat, lon) = latlon_from(lat1, lon1, azi, dis_along)
    return lat, lon
示例#2
0
文件: geo.py 项目: xumi1993/seispy
def geoproject(lat_p, lon_p, lat1, lon1, lat2, lon2):
    azi = distaz(lat1, lon1, lat2, lon2).baz
    dis_center = distaz(lat1, lon1, lat_p, lon_p).delta
    azi_center = distaz(lat1, lon1, lat_p, lon_p).baz
    dis_along = atand(tand(dis_center))*cosd(azi-azi_center)
    (lat, lon) = latlon_from(lat1, lon1, azi, dis_along)
    return lat, lon
示例#3
0
文件: rf.py 项目: Ji-Cong/seispy
def read_catalog(logpath,
                 b_time,
                 e_time,
                 stla,
                 stlo,
                 magmin=5.5,
                 magmax=10,
                 dismin=30,
                 dismax=90):
    col = ['date', 'evla', 'evlo', 'evdp', 'mag']
    eq_lst = pd.DataFrame(columns=col)
    with open(logpath) as f:
        lines = f.readlines()
        for line in lines:
            line_sp = line.strip().split()
            date_now = obspy.UTCDateTime.strptime(
                '.'.join(line_sp[0:3]) + 'T' + '.'.join(line_sp[4:7]),
                '%Y.%m.%dT%H.%M.%S')
            evla = float(line_sp[7])
            evlo = float(line_sp[8])
            evdp = float(line_sp[9])
            mw = float(line_sp[10])
            dis = seispy.distaz(stla, stlo, evla, evlo).delta
            # bazi = seispy.distaz(stla, stlo, evla, evlo).getBaz()
            if b_time <= date_now <= e_time and magmin <= mw <= magmax and dismin <= dis <= dismax:
                this_data = pd.DataFrame([[date_now, evla, evlo, evdp, mw]],
                                         columns=col)
                eq_lst = eq_lst.append(this_data, ignore_index=True)
    return eq_lst
示例#4
0
def prof_range(lat, lon):
    dis = [0]
    for i in range(lat.size - 1):
        dis.append(
            distaz(lat[i], lon[i], lat[i + 1],
                   lon[i + 1]).degreesToKilometers())
    return np.cumsum(dis)
示例#5
0
文件: ccp3d.py 项目: xumi1993/seispy
 def stack(self):
     """Search conversion points falling within a bin and stack them with bootstrap method.
     """
     for i, bin_info in enumerate(self.bin_loca):
         boot_stack = {}
         bin_mu = np.zeros(self.cpara.stack_range.size)
         bin_ci = np.zeros([self.cpara.stack_range.size, 2])
         bin_count = np.zeros(self.cpara.stack_range.size)
         self.logger.CCPlog.info(
             '{}/{} bin at lat: {:.3f} lon: {:.3f}'.format(
                 i + 1, self.bin_loca.shape[0], bin_info[0], bin_info[1]))
         idxs = self._select_sta(bin_info[0], bin_info[1])
         for j, dep in enumerate(self.cpara.stack_range):
             idx = int(j * self.stack_mul +
                       self.cpara.stack_range[0] / self.cpara.dep_val)
             bin_dep_amp = np.array([])
             for k in idxs:
                 stop_idx = np.where(self.rfdep[k]['stopindex'] >= idx)[0]
                 fall_idx = np.where(
                     distaz(self.rfdep[k]['piercelat'][stop_idx, idx],
                            self.rfdep[k]['piercelon'][stop_idx,
                                                       idx], bin_info[0],
                            bin_info[1]).delta < self.fzone[j])[0]
                 bin_dep_amp = np.append(
                     bin_dep_amp,
                     self.rfdep[k]['moveout_correct'][stop_idx[fall_idx],
                                                      idx])
             bin_mu[j], bin_ci[j], bin_count[j] = boot_bin_stack(
                 bin_dep_amp, n_samples=self.cpara.boot_samples)
         boot_stack['bin_lat'] = bin_info[0]
         boot_stack['bin_lon'] = bin_info[1]
         boot_stack['mu'] = bin_mu
         boot_stack['ci'] = bin_ci
         boot_stack['count'] = bin_count
         self.stack_data.append(boot_stack)
示例#6
0
def find_falling(proj, cpara, profile_range, profile_lat, profile_lon,
                 bin_radius):
    stack_data = np.zeros((profile_range.shape[0], 5), dtype=np.object)
    stack_rf = np.zeros([cpara.stack_range.shape[0], profile_range.shape[0]])
    event_count = np.zeros(
        [cpara.stack_range.shape[0], profile_range.shape[0]])
    dom = int(cpara.stack_val / cpara.dep_val)
    for i in range(profile_range.shape[0]):
        print(
            'calculate the RF stacks at the distance of {}km along the profile-------'
            .format(profile_range[i]))
        for j in range(cpara.stack_range.shape[0]):
            for k in range(proj.shape[0]):
                col = np.where(
                    distaz(
                        profile_lat[i], profile_lon[i], proj[k]['projlat'][
                            int(dom * cpara.stack_range[j]), :], proj[k]
                        ['projlon'][int(dom * cpara.stack_range[j]), :]).delta
                    < bin_radius[j])[0]
                if col.size != 0:
                    stack_rf[j, i] += np.sum(
                        proj[k]['moveout_correct'][int(dom *
                                                       cpara.stack_range[j]),
                                                   col])
                    event_count[j, i] += col.shape[0]
            if event_count[j, i] > 0:
                stack_rf[j, i] /= event_count[j, i]
        stack_data[i, 0] = profile_lat[i]
        stack_data[i, 1] = profile_lon[i]
        stack_data[i, 2] = profile_range[i]
        stack_data[i, 3] = stack_rf[:, i]
        stack_data[i, 4] = event_count[:, i]
    return stack_data
示例#7
0
def match_eq(eq_lst,
             pathname,
             stla,
             stlo,
             logger,
             ref_comp='Z',
             suffix='SAC',
             offset=None,
             tolerance=210,
             dateformat='%Y.%j.%H.%M.%S'):
    pattern = datestr2regex(dateformat)
    ref_eqs = glob.glob(join(pathname, '*{0}*{1}'.format(ref_comp, suffix)))
    if len(ref_eqs) == 0:
        raise SACFileNotFoundError(
            join(pathname, '*{0}*{1}'.format(ref_comp, suffix)))
    sac_files = []
    for ref_sac in ref_eqs:
        try:
            datestr = re.findall(pattern, ref_sac)[0]
        except IndexError:
            raise IndexError('Error data format of {} in {}'.format(
                pattern, ref_sac))
        if isinstance(offset, (int, float)):
            sac_files.append(
                [datestr,
                 UTCDateTime.strptime(datestr, dateformat), -offset])
        elif offset is None:
            try:
                tr = obspy.read(ref_sac)[0]
            except TypeError:
                continue
            sac_files.append(
                [datestr, tr.stats.starttime - tr.stats.sac.b, tr.stats.sac.o])
        else:
            raise TypeError('offset should be int or float type')
    new_col = ['dis', 'bazi', 'data', 'datestr']
    eq_match = pd.DataFrame(columns=new_col)
    for datestr, b_time, offs in sac_files:
        date_range_begin = b_time + timedelta(seconds=offs - tolerance)
        date_range_end = b_time + timedelta(seconds=offs + tolerance)
        results = eq_lst[(eq_lst.date > date_range_begin)
                         & (eq_lst.date < date_range_end)]
        if len(results) != 1:
            continue
        try:
            this_eq = EQ(pathname, datestr, suffix)
        except Exception as e:
            logger.RFlog.error(''.format(e))
            continue
        this_eq.get_time_offset(results.iloc[0]['date'])
        daz = distaz(stla, stlo, results.iloc[0]['evla'],
                     results.iloc[0]['evlo'])
        this_df = pd.DataFrame([[daz.delta, daz.baz, this_eq, datestr]],
                               columns=new_col,
                               index=results.index.values)
        eq_match = pd.concat([eq_match, this_df])
    ind = eq_match.index.drop_duplicates(keep=False)
    eq_match = eq_match.loc[ind]
    return pd.concat([eq_lst, eq_match], axis=1, join='inner')
示例#8
0
文件: rf4sta.py 项目: shineusn/seispy
def searcheq(stalat, stalon, daterange1, daterange2, gate_dis1, gate_dis2, gate_mw, evt_list):
    eq_lst = []
    fid_evtlist = open(evt_list)
    for evt in fid_evtlist.readlines():
        evt = evt.strip('\n')
        year_evt = int(evt.split()[0])
        mon_evt = int(evt.split()[1])
        day_evt = int(evt.split()[2])
        hour_evt = int(evt.split()[4])
        min_evt = int(evt.split()[5])
        sec_evt = int(evt.split()[6])
        lat_evt = float(evt.split()[7])
        lon_evt = float(evt.split()[8])
        dis_evt = seispy.distaz(stalat, stalon, lat_evt, lon_evt).delta
        bazi_evt = seispy.distaz(stalat, stalon, lat_evt, lon_evt).getBaz()
        dep_evt = float(evt.split()[9])
        mw_evt = float(evt.split()[10])
        date_evt = datetime.datetime(year_evt, mon_evt, day_evt, hour_evt, min_evt, sec_evt)
        if daterange1 <= date_evt <= daterange2 and gate_dis1 <= dis_evt <= gate_dis2 and mw_evt > gate_mw:
            matchedeq = [date_evt, lat_evt, lon_evt, dep_evt, dis_evt, bazi_evt, mw_evt]
            eq_lst.append(matchedeq)
    return eq_lst
示例#9
0
def search_stations(cpara, da, staname, stla, stlo):
    global sta_num
    projstla, projstlo = geoproject(stla, stlo, cpara.line[0, 0],
                                    cpara.line[0, 1], cpara.line[1, 0],
                                    cpara.line[1, 1])
    sta_dis = distaz(projstla, projstlo, stla, stlo).delta
    baz_sta_start = distaz(cpara.line[0, 0], cpara.line[0, 1], stla, stlo).baz
    baz_sta_end = distaz(cpara.line[1, 0], cpara.line[1, 1], stla, stlo).baz
    start_range = [np.mod(da.az + 90, 360), np.mod(da.az - 90, 360)]
    end_range = [np.mod(da.baz - 90, 360), np.mod(da.baz + 90, 360)]
    idx = np.where(
        ((baz_sta_start > start_range[0]) & (baz_sta_start < start_range[1]))
        & ((baz_sta_end < end_range[0]) | (baz_sta_end > end_range[1]))
        & (sta_dis < cpara.width))[0]
    if idx.size == 0:
        raise ValueError('No station beside this profile')
    if cpara.stack_sta_list != '':
        with open(cpara.stack_sta_list, 'w+') as f:
            for i in idx:
                f.write('{} {:3f} {:3f}\n'.format(staname[i], stla[i],
                                                  stlo[i]))
    return idx, projstla, projstlo
示例#10
0
文件: ccp3d.py 项目: xumi1993/seispy
def gen_center_bin(center_lat, center_lon, len_lat, len_lon, val):
    """
Create spaced grid point with coordinates of the center point in the area in spherical coordinates.

:param center_lat: Latitude of the center point.
:type center_lat: float
:param center_lon: Longitude of the center point.
:type center_lon: float
:param len_lat: Half length in degree along latitude axis.
:type len_lat: float
:param len_lon: Half length in degree along longitude axis.
:type len_lon: float
:param val: Interval in degree between adjacent grid point.
:type val: float
:return: Coordinates of Grid points.
:rtype: 2-D ndarray of floats with shape (n, 2), where n is the number of grid points.
    """
    lats = np.arange(0, 2 * len_lat, val)
    lons = np.arange(0, 2 * len_lon, val)
    plat, plon = latlon_from(center_lat, center_lon, 0, 90)
    da = distaz(plat, plon, center_lat, center_lon)
    begx = -len_lon
    begy = -len_lat
    bin_loca = []
    bin_mat = np.zeros([lats.size, lons.size, 2])
    bin_map = np.zeros([lats.size, lons.size]).astype(int)
    n = 0
    for j in range(lats.size):
        delyinc = j * val + begy
        delt = da.delta + delyinc
        for i in range(lons.size):
            azim = da.az + (begx + i * val) / cosd(delyinc)
            glat, glon = latlon_from(plat, plon, azim, delt)
            if glon > 180:
                glon -= 360
            bin_loca.append([glat, glon])
            bin_mat[j, i, 0] = glat
            bin_mat[j, i, 1] = glon
            bin_map[j, i] = n
            n += 1
    return np.array(bin_loca), bin_mat, bin_map
示例#11
0
        head = o
        config.read(head)
        break

lat1 = float(line.split('/')[0])
lon1 = float(line.split('/')[1])
lat2 = float(line.split('/')[2])
lon2 = float(line.split('/')[3])
depthdat = config.get('FileIO', 'depthdat')
stackfile = config.get('FileIO', 'stackfile')
# domperiod = float(config.get('para', 'domperiod'))
Profile_width = float(config.get('para', 'Profile_width'))
bin_radius = float(config.get('para', 'bin_radius'))
Stack_range = np.arange(300, 751)
smooth_para = 0.02
azi = seispy.distaz(lat1, lon1, lat2, lon2).baz
dis = seispy.distaz(lat1, lon1, lat2, lon2).delta
Profile_range = np.arange(0, seispy.geo.deg2km(dis), Profile_width)
Profile_lat = []
Profile_lon = []
for Profile_loca in Profile_range:
    (lat_loca,
     lon_loca) = seispy.geo.latlon_from(lat1, lon1, azi,
                                        seispy.geo.km2deg(Profile_loca))
    #    Profile_lat = np.append(Profile_lat, [lat_loca], axis=1)
    #    Profile_lon = np.append(Profile_lon, [lon_loca], axis=1)
    Profile_lat = np.append(Profile_lat, lat_loca)
    Profile_lon = np.append(Profile_lon, lon_loca)

# ----- Read depth .mat file -----#
depthmat = sio.loadmat(depthdat)
示例#12
0
文件: rf.py 项目: weijias-fork/seispy
def match_eq(eq_lst,
             pathname,
             stla,
             stlo,
             ref_comp='Z',
             suffix='SAC',
             offset=None,
             tolerance=210,
             dateformat='%Y.%j.%H.%M.%S',
             switchEN=False,
             reverseE=False,
             reverseN=False):
    pattern = datestr2regex(dateformat)
    ref_eqs = glob.glob(join(pathname, '*{0}*{1}'.format(ref_comp, suffix)))
    sac_files = []
    for ref_sac in ref_eqs:
        try:
            datestr = re.findall(pattern, ref_sac)[0]
        except IndexError:
            raise IndexError('Error data format in {}'.format(ref_sac))
        if isinstance(offset, (int, float)):
            sac_files.append([
                datestr,
                obspy.UTCDateTime.strptime(datestr, dateformat), -offset
            ])
        elif offset is None:
            try:
                tr = obspy.read(ref_sac)[0]
            except TypeError:
                continue
            sac_files.append([datestr, tr.stats.starttime, tr.stats.sac.o])
        else:
            raise TypeError('offset should be int or float type')

        # try:
        #     tr = obspy.read(ref_sac)[0]
        # except TypeError:
        #     continue
        # if offset is None:
        #     this_offset = tr.stats.sac.o
        # elif isinstance(offset, (int, float)):
        #     this_offset = -offset
        # else:
        #     raise TypeError('offset should be int or float type')
        # sac_files.append([datestr, tr.stats.starttime, this_offset])
    new_col = ['dis', 'bazi', 'data']
    eq_match = pd.DataFrame(columns=new_col)
    for datestr, b_time, offs in sac_files:
        date_range_begin = b_time + timedelta(seconds=offs - tolerance)
        date_range_end = b_time + timedelta(seconds=offs + tolerance)
        results = eq_lst[(eq_lst.date > date_range_begin)
                         & (eq_lst.date < date_range_end)]
        if len(results) != 1:
            continue
        try:
            this_eq = eq(pathname,
                         datestr,
                         suffix,
                         switchEN=switchEN,
                         reverseE=reverseE,
                         reverseN=reverseN)
        except Exception as e:
            continue
        this_eq.get_time_offset(results.iloc[0]['date'])
        daz = seispy.distaz(stla, stlo, results.iloc[0]['evla'],
                            results.iloc[0]['evlo'])
        this_df = pd.DataFrame([[daz.delta, daz.baz, this_eq]],
                               columns=new_col,
                               index=results.index.values)
        eq_match = eq_match.append(this_df)
    ind = eq_match.index.drop_duplicates(False)
    eq_match = eq_match.loc[ind]
    '''
    for i, evt in eq_lst.iterrows():
        tmp_datestr = []
        for datestr, b_time, offs in sac_files:
            if b_time + timedelta(seconds=offs - tolerance) <= evt['date'] \
                    <= b_time + timedelta(seconds=offs + tolerance):
                tmp_datestr.append(datestr)
        if len(tmp_datestr) == 1:
            try:
                this_eq = eq(pathname, tmp_datestr[0], suffix)
            except:
                continue
            this_eq.get_time_offset(evt['date'])
            daz = seispy.distaz(stla, stlo, evt['evla'], evt['evlo'])
            this_df = pd.DataFrame([[daz.delta, daz.baz, this_eq]], columns=new_col, index=[i])
            eq_match = eq_match.append(this_df)
    '''
    return pd.concat([eq_lst, eq_match], axis=1, join='inner')
示例#13
0
文件: ccp3d.py 项目: xumi1993/seispy
 def _select_sta(self, bin_lat, bin_lon):
     return np.where(
         distaz(bin_lat, bin_lon, self.stalst[:, 0],
                self.stalst[:, 1]).delta <= self.dismin)[0]
示例#14
0
VelocityModel = np.loadtxt(Velmod)
Depths = VelocityModel[:, 0]
Vs = VelocityModel[:, 2]
Vs = interpolate.interp1d(Depths, Vs, kind='linear')(YAxisRange)

# Stacking
Stack_data = np.zeros([center.shape[0], 5], dtype=np.object)
for i in range(center.shape[0]):
    print('Calculating %dth bin at %f/%f' % (i, center[i][0], center[i][1]))
    Stack_RF = np.zeros([Stack_range.shape[0], 1])
    Event_count = np.zeros([Stack_range.shape[0], 1])
    for j in range(Stack_range.shape[0]):
        # bin_radius = np.sqrt(0.5*domperiod*Vs[2*Stack_range[j] ]*Stack_range[j])
        for k in range(RFdepth.shape[1]):
            if seispy.distaz(center[i][0], center[i][1],
                             RFdepth[0, k]['stalat'][0][0],
                             RFdepth[0, k]['stalon'][0][0]).delta >= 2:
                continue
            for l in range(RFdepth[0, k]['Piercelat'].shape[1]):
                if seispy.distaz(
                        center[i][0], center[i][1],
                        RFdepth[0, k]['Piercelat'][2 * Stack_range[j], l],
                        RFdepth[0, k]['Piercelon'][2 * Stack_range[j], l]
                ).degreesToKilometers() < bin_radius:
                    Stack_RF[j][0] += RFdepth[0, k]['moveout_correct'][
                        2 * Stack_range[j], l]
                    Event_count[j][0] += 1
        if Event_count[j][0] > 0:
            Stack_RF[j][0] /= Event_count[j][0]
    Stack_data[i][0] = center[i][0]
    Stack_data[i][1] = center[i][1]
示例#15
0
#################################
eq_lst = []
ex_sac = obspy.read(glob.glob(os.path.join(data_path, staname, '*.'+comp+'.*[Ss][Aa][Cc]'))[0])[0]
stalat = ex_sac.stats.sac.stla
stalon = ex_sac.stats.sac.stlo
for evt in fid_evtlist.readlines():
    evt = evt.strip('\n')
    year_evt = int(evt.split()[0])
    mon_evt = int(evt.split()[1])
    day_evt = int(evt.split()[2])
    hour_evt = int(evt.split()[4])
    min_evt = int(evt.split()[5])
    sec_evt = int(evt.split()[6])
    lat_evt = float(evt.split()[7])
    lon_evt = float(evt.split()[8])
    dis_evt = seispy.distaz(stalat, stalon, lat_evt, lon_evt).delta
    bazi_evt = seispy.distaz(stalat, stalon, lat_evt, lon_evt).getBaz()
    dep_evt = float(evt.split()[9])
    mw_evt = float(evt.split()[10])
    date_evt = datetime.datetime(year_evt, mon_evt, day_evt, hour_evt, min_evt, sec_evt)
    if daterange1 <= date_evt <= daterange2 and gate_dis1 <= dis_evt <= gate_dis2 and mw_evt > gate_mw:
        matchedeq = [date_evt, lat_evt, lon_evt, dep_evt, dis_evt, bazi_evt, mw_evt]
        eq_lst.append(matchedeq)

#################################
# -------- Assign Files --------#
#################################
eq = []
for nowevt in eq_lst:
    find_result = []
    for sac in glob.glob(os.path.join(data_path, staname, '*.'+comp+'.*[Ss][Aa][Cc]')):
示例#16
0
        config.read(head)
        break

# read parameters
lat1 = float(line.split('/')[0])
lon1 = float(line.split('/')[1])
lat2 = float(line.split('/')[2])
lon2 = float(line.split('/')[3])
depthdat = config.get('FileIO', 'depthdat')
stackfile = config.get('FileIO', 'stackfile')
Velmod = config.get('FileIO', 'Velmod')
stalist = config.get('FileIO', 'stalist')
domperiod = float(config.get('para', 'domperiod'))
Profile_width = float(config.get('para', 'Profile_width'))
Stack_range = np.arange(1, 101)
azi = seispy.distaz(lat1, lon1, lat2, lon2).baz
dis = seispy.distaz(lat1, lon1, lat2, lon2).delta
Profile_range = np.arange(0, seispy.geo.deg2km(dis), Profile_width)
Profile_lat = []
Profile_lon = []
for Profile_loca in Profile_range:
    (lat_loca, lon_loca) = seispy.geo.latlon_from(lat1, lon1, azi, seispy.geo.km2deg(Profile_loca))
    Profile_lat = np.append(Profile_lat, [lat_loca], axis=1)
    Profile_lon = np.append(Profile_lon, [lon_loca], axis=1)

# read depth data
depthmat = sio.loadmat(depthdat)
RFdepth = depthmat['YN_RFdepth']

# find stations beside the profile
stalat_all = RFdepth[0, 0::]['stalat']
示例#17
0
        break

# read parameters
lat1 = float(line.split('/')[0])
lon1 = float(line.split('/')[1])
lat2 = float(line.split('/')[2])
lon2 = float(line.split('/')[3])
depthdat = config.get('FileIO', 'depthdat')
stackfile = config.get('FileIO', 'stackfile')
Velmod = config.get('FileIO', 'Velmod')
stalist = config.get('FileIO', 'stalist')
domperiod = float(config.get('para', 'domperiod'))
Profile_width = float(config.get('para', 'Profile_width'))
# proj_width = float(config.get('para', 'proj_width'))
Stack_range = np.arange(1, 101)
azi = seispy.distaz(lat1, lon1, lat2, lon2).baz
dis = seispy.distaz(lat1, lon1, lat2, lon2).delta
Profile_range = np.arange(0, seispy.geo.deg2km(dis), Profile_width)
Profile_lat = []
Profile_lon = []
for Profile_loca in Profile_range:
    (lat_loca,
     lon_loca) = seispy.geo.latlon_from(lat1, lon1, azi,
                                        seispy.geo.km2deg(Profile_loca))
    #print(lat_loca, lon_loca)
    Profile_lat = np.append(Profile_lat, [lat_loca])
    Profile_lon = np.append(Profile_lon, [lon_loca])

# read depth data
depthmat = sio.loadmat(depthdat)
RFdepth = depthmat['YN_RFdepth']
示例#18
0
Depths = VelocityModel[:, 0]
Vs = VelocityModel[:, 2]
Vs = interpolate.interp1d(Depths, Vs, kind="linear")(YAxisRange)

# Stacking
Stack_data = np.zeros([center.shape[0], 5], dtype=np.object)
for i in range(center.shape[0]):
    print("Calculating %dth bin at %f/%f" % (i, center[i][0], center[i][1]))
    Stack_RF = np.zeros([Stack_range.shape[0], 1])
    Event_count = np.zeros([Stack_range.shape[0], 1])
    for j in range(Stack_range.shape[0]):
        # bin_radius = np.sqrt(0.5*domperiod*Vs[2*Stack_range[j] ]*Stack_range[j])
        for k in range(RFdepth.shape[1]):
            if (
                seispy.distaz(
                    center[i][0], center[i][1], RFdepth[0, k]["stalat"][0][0], RFdepth[0, k]["stalon"][0][0]
                ).delta
                >= 2
            ):
                continue
            for l in range(RFdepth[0, k]["Piercelat"].shape[1]):
                if (
                    seispy.distaz(
                        center[i][0],
                        center[i][1],
                        RFdepth[0, k]["Piercelat"][2 * Stack_range[j], l],
                        RFdepth[0, k]["Piercelon"][2 * Stack_range[j], l],
                    ).degreesToKilometers()
                    < bin_radius
                ):
                    Stack_RF[j][0] += RFdepth[0, k]["moveout_correct"][2 * Stack_range[j], l]
示例#19
0
#################################
# --------- Search eq ----------#
#################################
eq_lst = []
for evt in fid_evtlist.readlines():
    evt = evt.strip('\n')
    year_evt = int(evt.split()[0])
    mon_evt = int(evt.split()[1])
    day_evt = int(evt.split()[2])
    hour_evt = int(evt.split()[4])
    min_evt = int(evt.split()[5])
    sec_evt = int(evt.split()[6])
    lat_evt = float(evt.split()[7])
    lon_evt = float(evt.split()[8])
    dis_evt = seispy.distaz(stalat, stalon, lat_evt, lon_evt).delta
    bazi_evt = seispy.distaz(stalat, stalon, lat_evt, lon_evt).getBaz()
    dep_evt = float(evt.split()[9])
    mw_evt = float(evt.split()[10])
    date_evt = datetime.datetime(year_evt, mon_evt, day_evt, hour_evt, min_evt,
                                 sec_evt)
    if daterange1 <= date_evt <= daterange2 and gate_dis1 <= dis_evt <= gate_dis2 and mw_evt > gate_mw:
        matchedeq = [
            date_evt, lat_evt, lon_evt, dep_evt, dis_evt, bazi_evt, mw_evt
        ]
        eq_lst.append(matchedeq)

#################################
# -------- Assign Files --------#
#################################
eq = []
示例#20
0
文件: PyCCP.py 项目: xumi1993/seispy
        config.read(head)
        break

# read parameters
lat1 = float(line.split('/')[0])
lon1 = float(line.split('/')[1])
lat2 = float(line.split('/')[2])
lon2 = float(line.split('/')[3])
depthdat = config.get('FileIO', 'depthdat')
stackfile = config.get('FileIO', 'stackfile')
Velmod = config.get('FileIO', 'Velmod')
stalist = config.get('FileIO', 'stalist')
domperiod = float(config.get('para', 'domperiod'))
Profile_width = float(config.get('para', 'Profile_width'))
Stack_range = np.arange(1, 101)
azi = seispy.distaz(lat1, lon1, lat2, lon2).baz
dis = seispy.distaz(lat1, lon1, lat2, lon2).delta
Profile_range = np.arange(0, seispy.geo.deg2km(dis), Profile_width)
Profile_lat = []
Profile_lon = []
for Profile_loca in Profile_range:
    (lat_loca, lon_loca) = seispy.geo.latlon_from(lat1, lon1, azi, seispy.geo.km2deg(Profile_loca))
    Profile_lat = np.append(Profile_lat, [lat_loca], axis=1)
    Profile_lon = np.append(Profile_lon, [lon_loca], axis=1)

# read depth data
depthmat = sio.loadmat(depthdat)
RFdepth = depthmat['RFdepth']

# find stations beside the profile
stalat_all = RFdepth[0, 0::]['stalat']
示例#21
0
def gen_profile(lineloca, slid_val):
    da = distaz(lineloca[0, 0], lineloca[0, 1], lineloca[1, 0], lineloca[1, 1])
    profile_range = np.arange(0, da.degreesToKilometers(), slid_val)
    profile_lat, profile_lon = latlon_from(lineloca[0, 0], lineloca[0, 1],
                                           da.baz, profile_range)
    return da, profile_range, profile_lat, profile_lon
示例#22
0
        head = o
        config.read(head)
        break

lat1 = float(line.split('/')[0])
lon1 = float(line.split('/')[1])
lat2 = float(line.split('/')[2])
lon2 = float(line.split('/')[3])
depthdat = config.get('FileIO', 'depthdat')
stackfile = config.get('FileIO', 'stackfile')
# domperiod = float(config.get('para', 'domperiod'))
Profile_width = float(config.get('para', 'Profile_width'))
bin_radius = float(config.get('para', 'bin_radius'))
Stack_range = np.arange(300, 751)
smooth_para = 0.02
azi = seispy.distaz(lat1, lon1, lat2, lon2).baz
dis = seispy.distaz(lat1, lon1, lat2, lon2).delta
Profile_range = np.arange(0, seispy.geo.deg2km(dis), Profile_width)
Profile_lat = []
Profile_lon = []
for Profile_loca in Profile_range:
    (lat_loca, lon_loca) = seispy.geo.latlon_from(lat1, lon1, azi, seispy.geo.km2deg(Profile_loca))
#    Profile_lat = np.append(Profile_lat, [lat_loca], axis=1)
#    Profile_lon = np.append(Profile_lon, [lon_loca], axis=1)
    Profile_lat = np.append(Profile_lat, lat_loca)
    Profile_lon = np.append(Profile_lon, lon_loca)


# ----- Read depth .mat file -----#
depthmat = sio.loadmat(depthdat)
RFdepth = depthmat['YN_RFdepth']