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 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 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)
class TauPCreate(object):
"""
The seismic travel time calculation method of [Buland1983]_.
The calculation method is described in [Buland1983]_. This creates the
SlownessModel and tau branches and saves them for later use.
"""
def __init__(self, input_filename, output_filename, verbose=False,
min_delta_p=0.1, max_delta_p=11.0, max_depth_interval=115.0,
max_range_interval=2.5, max_interp_error=0.05,
allow_inner_core_s=True):
self.input_filename = input_filename
self.output_filename = output_filename
self.debug = verbose
self.min_delta_p = min_delta_p
self.max_delta_p = max_delta_p
self.max_depth_interval = max_depth_interval
self.max_range_interval = max_range_interval
self.max_interp_error = max_interp_error
self.allow_inner_core_s = allow_inner_core_s
def load_velocity_model(self):
"""
Try to load a velocity model.
"""
# Read the velocity model file.
filename = self.input_filename
if self.debug:
print("filename =", filename)
self.v_mod = VelocityModel.read_velocity_file(filename)
if self.v_mod is None:
raise IOError("Velocity model file not found: " + filename)
# If model was read:
if self.debug:
print("Done reading velocity model.")
print("Radius of model " + self.v_mod.model_name + " is " +
str(self.v_mod.radius_of_planet))
# if self.debug:
# print("velocity mode: " + self.v_mod)
return self.v_mod
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 run(self):
"""
Create a tau model from a velocity model.
Called by :func:`build_taup_model` after :meth:`load_velocity_model`;
calls :meth:`create_tau_model` and writes the result to a ``.npy``
file.
"""
try:
self.tau_model = self.create_tau_model(self.v_mod)
# this reassigns model! Used to be TauModel() class,
# now it's an instance of it.
if self.debug:
print("Done calculating Tau branches.")
dirname = os.path.dirname(self.output_filename)
if dirname and not os.path.exists(dirname):
os.makedirs(dirname)
self.tau_model.serialize(self.output_filename)
if self.debug:
print("Done Saving " + self.output_filename)
except IOError as e:
print("Tried to write!\n Caught IOError. Do you have write "
"permission in this directory?", e)
except KeyError as e:
print('file not found or wrong key?', e)
finally:
if self.debug:
print("Method run is done, but not necessarily successful.")
class TauP_Create(object):
"""
The seismic travel time calculation method of [Buland1983]_.
The calculation method is described in [Buland1983]_. This creates the
SlownessModel and tau branches and saves them for later use.
"""
def __init__(self, input_filename, output_filename, verbose=False,
min_delta_p=0.1, max_delta_p=11.0, max_depth_interval=115.0,
max_range_interval=2.5, max_interp_error=0.05,
allow_inner_core_s=True):
self.input_filename = input_filename
self.output_filename = output_filename
self.debug = verbose
self.min_delta_p = min_delta_p
self.max_delta_p = max_delta_p
self.max_depth_interval = max_depth_interval
self.max_range_interval = max_range_interval
self.max_interp_error = max_interp_error
self.allow_inner_core_s = allow_inner_core_s
def loadVMod(self):
"""
Try to load a velocity model.
"""
# Read the velocity model file.
filename = self.input_filename
if self.debug:
print("filename =", filename)
self.vMod = VelocityModel.readVelocityFile(filename)
if self.vMod is None:
raise IOError("Velocity model file not found: " + filename)
# If model was read:
if self.debug:
print("Done reading velocity model.")
print("Radius of model " + self.vMod.modelName + " is " +
str(self.vMod.radiusOfEarth))
# if self.debug:
# print("velocity mode: " + self.vMod)
return self.vMod
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 run(self):
"""
Create a tau model from a velocity model.
Called by :func:`build_taup_model` after :meth:`loadVMod`; calls
:meth:`createTauModel` and writes the result to a ``.npy`` file.
"""
try:
self.tMod = self.createTauModel(self.vMod)
# this reassigns model! Used to be TauModel() class,
# now it's an instance of it.
if self.debug:
print("Done calculating Tau branches.")
if not os.path.exists(os.path.dirname(self.output_filename)):
os.makedirs(os.path.dirname(self.output_filename))
self.tMod.serialize(self.output_filename)
if self.debug:
print("Done Saving " + self.output_filename)
except IOError as e:
print("Tried to write!\n Caught IOError. Do you have write "
"permission in this directory?", e)
except KeyError as e:
print('file not found or wrong key?', e)
finally:
if self.debug:
print("Method run is done, but not necessarily successful.")
