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.")