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
def taumodel(model): """Returns a TauModel from string, or the argument in case of TypeError, assuming the latter is already a TauModel """ try: return TauModel.from_file(model) # NOTE from_file has an argument cache that we ignore because of a bug (reported) # in obspy 1.0.2 if cache is False! except TypeError: return model # ok, we assume the argument is already a TaupModel then
def create_tau_model(self, v_mod): """ Create :class:`~.TauModel` from velocity model. First, a slowness model is created from the velocity model, and then it is passed to :class:`~.TauModel`. """ if v_mod is None: raise ValueError("v_mod is None.") if v_mod.is_spherical is False: raise Exception("Flat slowness model not yet implemented.") SlownessModel.debug = self.debug if self.debug: print("Using parameters provided in TauP_config.ini (or defaults " "if not) to call SlownessModel...") self.s_mod = SlownessModel(v_mod, self.min_delta_p, self.max_delta_p, self.max_depth_interval, self.max_range_interval * pi / 180.0, self.max_interp_error, self.allow_inner_core_s, _DEFAULT_VALUES["slowness_tolerance"]) if self.debug: print("Parameters are:") print("taup.create.min_delta_p = " + str(self.s_mod.min_delta_p) + " sec / radian") print("taup.create.max_delta_p = " + str(self.s_mod.max_delta_p) + " sec / radian") print("taup.create.max_depth_interval = " + str(self.s_mod.max_depth_interval) + " kilometers") print("taup.create.max_range_interval = " + str(self.s_mod.max_range_interval) + " degrees") print("taup.create.max_interp_error = " + str(self.s_mod.max_interp_error) + " seconds") print("taup.create.allow_inner_core_s = " + str(self.s_mod.allow_inner_core_s)) print("Slow model " + " " + str(self.s_mod.get_num_layers(True)) + " P layers," + str(self.s_mod.get_num_layers(False)) + " S layers") # if self.debug: # print(self.s_mod) # set the debug flags to value given here: TauModel.debug = self.debug SlownessModel.debug = self.debug # Creates tau model from slownesses. return TauModel(self.s_mod, radius_of_planet=v_mod.radius_of_planet)
def createTauModel(self, vMod): """ Create :class:`~.TauModel` from velocity model. First, a slowness model is created from the velocity model, and then it is passed to :class:`~.TauModel`. """ if vMod is None: raise ValueError("vMod is None.") if vMod.isSpherical is False: raise Exception("Flat slowness model not yet implemented.") SlownessModel.DEBUG = self.debug if self.debug: print("Using parameters provided in TauP_config.ini (or defaults " "if not) to call SlownessModel...") self.sMod = SlownessModel(vMod, self.min_delta_p, self.max_delta_p, self.max_depth_interval, self.max_range_interval * pi / 180.0, self.max_interp_error, self.allow_inner_core_s, SlownessModel.DEFAULT_SLOWNESS_TOLERANCE) if self.debug: print("Parameters are:") print("taup.create.min_delta_p = " + str(self.sMod.minDeltaP) + " sec / radian") print("taup.create.maxDeltaP = " + str(self.sMod.maxDeltaP) + " sec / radian") print("taup.create.maxDepthInterval = " + str(self.sMod.maxDepthInterval) + " kilometers") print("taup.create.maxRangeInterval = " + str(self.sMod.maxRangeInterval) + " degrees") print("taup.create.maxInterpError = " + str(self.sMod.maxInterpError) + " seconds") print("taup.create.allowInnerCoreS = " + str(self.sMod.allowInnerCoreS)) print("Slow model " + " " + str(self.sMod.getNumLayers(True)) + " P layers," + str(self.sMod.getNumLayers(False)) + " S layers") # if self.debug: # print(self.sMod) # set the debug flags to value given here: TauModel.DEBUG = self.debug SlownessModel.DEBUG = self.debug # Creates tau model from slownesses. return TauModel(self.sMod)
def test_split(self): depth = 110 tau_model = TauModel.from_file('iasp91') split_t_mod = tau_model.split_branch(depth) self.assertEqual(tau_model.tau_branches.shape[1] + 1, split_t_mod.tau_branches.shape[1]) self.assertEqual(len(tau_model.ray_params) + 2, len(split_t_mod.ray_params)) branch_count = tau_model.tau_branches.shape[1] split_branch_index = tau_model.find_branch(depth) new_p_ray_param = split_t_mod.s_mod.get_slowness_layer( split_t_mod.s_mod.layer_number_above(depth, True), True)['bot_p'] new_s_ray_param = split_t_mod.s_mod.get_slowness_layer( split_t_mod.s_mod.layer_number_above(depth, False), False)['bot_p'] p_index = s_index = len(split_t_mod.ray_params) ray_params = split_t_mod.ray_params for j in range(len(ray_params)): if new_p_ray_param == ray_params[j]: p_index = j if new_s_ray_param == ray_params[j]: s_index = j self.assertTrue(p_index == len(split_t_mod.ray_params) or s_index < p_index) for b in range(branch_count): orig = tau_model.get_tau_branch(b, True) if b < split_branch_index: depth_branch = split_t_mod.get_tau_branch(b, True) self.assertGreater(depth_branch.dist[p_index], 0) self.assertGreater(depth_branch.time[p_index], 0) elif b > split_branch_index: depth_branch = split_t_mod.get_tau_branch(b + 1, True) self.assertAlmostEqual(depth_branch.dist[p_index], 0, delta=0.00000001) self.assertAlmostEqual(depth_branch.time[p_index], 0, delta=0.00000001) else: # the split one continue np.testing.assert_allclose(orig.dist[0:s_index], depth_branch.dist[0:s_index], atol=0.00000001) np.testing.assert_allclose(orig.time[0:s_index], depth_branch.time[0:s_index], atol=0.00000001) orig_len = len(orig.dist) if s_index < orig_len: self.assertEqual(orig_len + 2, len(depth_branch.dist)) np.testing.assert_allclose( orig.dist[s_index:p_index - 1], depth_branch.dist[s_index + 1:p_index], atol=0.00000001) np.testing.assert_allclose( orig.time[s_index:p_index - 1], depth_branch.time[s_index + 1:p_index], atol=0.00000001) np.testing.assert_allclose( orig.dist[p_index:orig_len-s_index-2], depth_branch.dist[p_index+2:orig_len-s_index], atol=0.00000001) np.testing.assert_allclose( orig.time[p_index:orig_len-s_index-2], depth_branch.time[p_index+2:orig_len-s_index], atol=0.00000001) # now check branch split orig = tau_model.get_tau_branch(split_branch_index, True) above = split_t_mod.get_tau_branch(split_branch_index, True) below = split_t_mod.get_tau_branch(split_branch_index + 1, True) self.assertAlmostEqual(above.min_ray_param, below.max_ray_param, 8) for i in range(len(above.dist)): if i < s_index: self.assertAlmostEqual(orig.dist[i], above.dist[i], delta=0.000000001) elif i == s_index: # new value should be close to average of values to either side self.assertAlmostEqual((orig.dist[i - 1] + orig.dist[i]) / 2, above.dist[i], delta=0.00001) elif i > s_index and i < p_index: self.assertAlmostEqual(orig.dist[i - 1], above.dist[i] + below.dist[i], delta=0.000000001) elif i == p_index: # new value should be close to average of values to either side self.assertAlmostEqual( (orig.dist[i - 2] + orig.dist[i - 1]) / 2, above.dist[i] + below.dist[i], delta=0.0001) else: self.assertAlmostEqual(orig.dist[i - 2], above.dist[i] + below.dist[i], delta=0.000000001)
def setUp(self): self.depth = 119 self.tMod = TauModel.from_file("iasp91").depth_correct(self.depth)
def setUp(self): self.depth = 119 self.tau_model = TauModel.from_file('iasp91').depth_correct(self.depth)
def test_split(self): depth = 110 tau_model = TauModel.from_file('iasp91') split_t_mod = tau_model.split_branch(depth) shape1 = tau_model.tau_branches.shape[1] + 1 shape2 = split_t_mod.tau_branches.shape[1] assert shape1 == shape2 assert len(tau_model.ray_params) + 2 == len(split_t_mod.ray_params) branch_count = tau_model.tau_branches.shape[1] split_branch_index = tau_model.find_branch(depth) new_p_ray_param = split_t_mod.s_mod.get_slowness_layer( split_t_mod.s_mod.layer_number_above(depth, True), True)['bot_p'] new_s_ray_param = split_t_mod.s_mod.get_slowness_layer( split_t_mod.s_mod.layer_number_above(depth, False), False)['bot_p'] p_index = s_index = len(split_t_mod.ray_params) ray_params = split_t_mod.ray_params for j in range(len(ray_params)): if new_p_ray_param == ray_params[j]: p_index = j if new_s_ray_param == ray_params[j]: s_index = j assert p_index == len(split_t_mod.ray_params) or s_index < p_index for b in range(branch_count): orig = tau_model.get_tau_branch(b, True) if b < split_branch_index: depth_branch = split_t_mod.get_tau_branch(b, True) assert depth_branch.dist[p_index] > 0 assert depth_branch.time[p_index] > 0 elif b > split_branch_index: depth_branch = split_t_mod.get_tau_branch(b + 1, True) assert np.isclose(depth_branch.dist[p_index], 0) assert np.isclose(depth_branch.time[p_index], 0) else: # the split one continue np.testing.assert_allclose(orig.dist[0:s_index], depth_branch.dist[0:s_index], atol=0.00000001) np.testing.assert_allclose(orig.time[0:s_index], depth_branch.time[0:s_index], atol=0.00000001) orig_len = len(orig.dist) if s_index < orig_len: assert orig_len + 2 == len(depth_branch.dist) np.testing.assert_allclose( orig.dist[s_index:p_index - 1], depth_branch.dist[s_index + 1:p_index], atol=0.00000001) np.testing.assert_allclose( orig.time[s_index:p_index - 1], depth_branch.time[s_index + 1:p_index], atol=0.00000001) np.testing.assert_allclose( orig.dist[p_index:orig_len - s_index - 2], depth_branch.dist[p_index + 2:orig_len - s_index], atol=0.00000001) np.testing.assert_allclose( orig.time[p_index:orig_len - s_index - 2], depth_branch.time[p_index + 2:orig_len - s_index], atol=0.00000001) # now check branch split orig = tau_model.get_tau_branch(split_branch_index, True) above = split_t_mod.get_tau_branch(split_branch_index, True) below = split_t_mod.get_tau_branch(split_branch_index + 1, True) assert np.isclose(above.min_ray_param, below.max_ray_param) for i in range(len(above.dist)): if i < s_index: assert np.isclose(orig.dist[i], above.dist[i]) elif i == s_index: # new value should be close to average of values to either side assert np.isclose((orig.dist[i - 1] + orig.dist[i]) / 2, above.dist[i], atol=0.00001) elif s_index < i < p_index: assert np.isclose(orig.dist[i - 1], above.dist[i] + below.dist[i]) elif i == p_index: # new value should be close to average of values to either side val1 = (orig.dist[i - 2] + orig.dist[i - 1]) / 2 val2 = above.dist[i] + below.dist[i] assert np.isclose(val1, val2, atol=0.0001) else: val1 = orig.dist[i - 2] val2 = above.dist[i] + below.dist[i] assert np.isclose(val1, val2, atol=0.000000001)
def test_split(self): depth = 110 tau_model = TauModel.from_file('iasp91') split_t_mod = tau_model.split_branch(depth) self.assertEqual(tau_model.tau_branches.shape[1] + 1, split_t_mod.tau_branches.shape[1]) self.assertEqual( len(tau_model.ray_params) + 2, len(split_t_mod.ray_params)) branch_count = tau_model.tau_branches.shape[1] split_branch_index = tau_model.find_branch(depth) new_p_ray_param = split_t_mod.s_mod.get_slowness_layer( split_t_mod.s_mod.layer_number_above(depth, True), True)['bot_p'] new_s_ray_param = split_t_mod.s_mod.get_slowness_layer( split_t_mod.s_mod.layer_number_above(depth, False), False)['bot_p'] p_index = s_index = len(split_t_mod.ray_params) ray_params = split_t_mod.ray_params for j in range(len(ray_params)): if new_p_ray_param == ray_params[j]: p_index = j if new_s_ray_param == ray_params[j]: s_index = j self.assertTrue(p_index == len(split_t_mod.ray_params) or s_index < p_index) for b in range(branch_count): orig = tau_model.get_tau_branch(b, True) if b < split_branch_index: depth_branch = split_t_mod.get_tau_branch(b, True) self.assertGreater(depth_branch.dist[p_index], 0) self.assertGreater(depth_branch.time[p_index], 0) elif b > split_branch_index: depth_branch = split_t_mod.get_tau_branch(b + 1, True) self.assertAlmostEqual(depth_branch.dist[p_index], 0, delta=0.00000001) self.assertAlmostEqual(depth_branch.time[p_index], 0, delta=0.00000001) else: # the split one continue np.testing.assert_allclose(orig.dist[0:s_index], depth_branch.dist[0:s_index], atol=0.00000001) np.testing.assert_allclose(orig.time[0:s_index], depth_branch.time[0:s_index], atol=0.00000001) orig_len = len(orig.dist) if s_index < orig_len: self.assertEqual(orig_len + 2, len(depth_branch.dist)) np.testing.assert_allclose(orig.dist[s_index:p_index - 1], depth_branch.dist[s_index + 1:p_index], atol=0.00000001) np.testing.assert_allclose(orig.time[s_index:p_index - 1], depth_branch.time[s_index + 1:p_index], atol=0.00000001) np.testing.assert_allclose( orig.dist[p_index:orig_len - s_index - 2], depth_branch.dist[p_index + 2:orig_len - s_index], atol=0.00000001) np.testing.assert_allclose( orig.time[p_index:orig_len - s_index - 2], depth_branch.time[p_index + 2:orig_len - s_index], atol=0.00000001) # now check branch split orig = tau_model.get_tau_branch(split_branch_index, True) above = split_t_mod.get_tau_branch(split_branch_index, True) below = split_t_mod.get_tau_branch(split_branch_index + 1, True) self.assertAlmostEqual(above.min_ray_param, below.max_ray_param, 8) for i in range(len(above.dist)): if i < s_index: self.assertAlmostEqual(orig.dist[i], above.dist[i], delta=0.000000001) elif i == s_index: # new value should be close to average of values to either side self.assertAlmostEqual((orig.dist[i - 1] + orig.dist[i]) / 2, above.dist[i], delta=0.00001) elif i > s_index and i < p_index: self.assertAlmostEqual(orig.dist[i - 1], above.dist[i] + below.dist[i], delta=0.000000001) elif i == p_index: # new value should be close to average of values to either side self.assertAlmostEqual( (orig.dist[i - 2] + orig.dist[i - 1]) / 2, above.dist[i] + below.dist[i], delta=0.0001) else: self.assertAlmostEqual(orig.dist[i - 2], above.dist[i] + below.dist[i], delta=0.000000001)
def tau_model(self): """Return the tau model for testing.""" return TauModel.from_file('iasp91').depth_correct(self.depth)