def __init__(self): super(TimeFrequencyFrame, self).__init__() self.setupUi(self) self.__stations_dir = None self.__metadata_manager = None self.inventory = {} self._stations_info = {} self.tr1 = [] self.tr2 = [] self.canvas_plot1 = MatplotlibCanvas(self.widget_plot_up, nrows=2) # self.canvas_plot1.set_xlabel(1, "Time (s)") # self.canvas_plot1.set_ylabel(0, "Amplitude ") # self.canvas_plot1.set_ylabel(1, "Frequency (Hz)") self.canvas_plot2 = MatplotlibCanvas(self.widget_plot_down, nrows=2) # self.canvas_plot2.set_xlabel(1, "Time (s)") # self.canvas_plot2.set_ylabel(0, "Amplitude ") # self.canvas_plot2.set_ylabel(1, "Frequency (Hz)") # Binding self.canvas_plot1.mpl_connect('key_press_event', self.key_pressed) self.canvas_plot2.mpl_connect('key_press_event', self.key_pressed) self.root_path_bind = BindPyqtObject(self.rootPathForm, self.onChange_root_path) self.dataless_path_bind = BindPyqtObject(self.datalessPathForm) self.metadata_path_bind = BindPyqtObject(self.datalessPathForm, self.onChange_metadata_path) # Add file selector to the widget self.file_selector = FilesView( self.root_path_bind.value, parent=self.fileSelectorWidget, on_change_file_callback=lambda file_path: self.onChange_file( file_path)) # Binds self.selectDirBtn.clicked.connect( lambda: self.on_click_select_directory(self.root_path_bind)) self.datalessBtn.clicked.connect( lambda: self.on_click_select_file(self.dataless_path_bind)) # Action Buttons self.actionSettings.triggered.connect( lambda: self.open_parameters_settings()) self.actionOpen_Help.triggered.connect(lambda: self.open_help()) self.actionOpen_Spectral_Analysis.triggered.connect( self.time_frequency_advance) self.plotBtn.clicked.connect(self.plot_seismogram) self.stationsBtn.clicked.connect(self.stations_info) # help Documentation self.help = HelpDoc() # Parameters settings self.parameters = ParametersSettings()
def __init__(self): super(MTIFrame, self).__init__() self.setupUi(self) #super(MTIFrame, self).__init__() self.setupUi(self) self.__stations_dir = None self.__metadata_manager = None self.inventory = {} self._stations_info = {} self.stream = None # Binding self.root_path_bind = BindPyqtObject(self.rootPathForm) #self.dataless_path_bind = BindPyqtObject(self.datalessPathForm) self.metadata_path_bind = BindPyqtObject(self.datalessPathForm, self.onChange_metadata_path) self.earth_path_bind = BindPyqtObject(self.earth_modelPathForm) # Binds self.selectDirBtn.clicked.connect( lambda: self.on_click_select_directory(self.root_path_bind)) self.datalessBtn.clicked.connect( lambda: self.on_click_select_metadata_file(self.metadata_path_bind )) self.earthmodelBtn.clicked.connect( lambda: self.on_click_select_file(self.earth_path_bind)) # Action Buttons self.actionSettings.triggered.connect( lambda: self.open_parameters_settings()) self.plotBtn.clicked.connect(self.plot_seismograms) self.actionSettings.triggered.connect( lambda: self.open_parameters_settings()) self.actionWrite.triggered.connect(self.write) self.actionEarth_Model.triggered.connect( lambda: self.open_earth_model()) self.actionFrom_File.triggered.connect( lambda: self.load_event_from_isolapath()) self.actionOpen_Help.triggered.connect(lambda: self.open_help()) self.stationsBtn.clicked.connect(self.stationsInfo) self.run_inversionBtn.clicked.connect(lambda: self.run_inversion()) self.stations_mapBtn.clicked.connect(lambda: self.plot_map_stations()) self.plot_solutionBtn.clicked.connect(lambda: self.plot_solution()) #self.earthmodelBtn.clicked.connect(self.read_earth_model) # Parameters settings self.parameters = ParametersSettings() self.earth_model = CrustalModelParametersFrame() # help Documentation self.help = HelpDoc()
def __init__(self): self.main_frame = None self.time_frequency_frame = None self.earthquake_analysis_frame = None self.array_analysis_frame = None self.moment_tensor_frame = None self.receiver_functions_frame = None self.project_frame = None self.synthetics_frame = None self.data_download_frame = None self.ppds_frame = None self.realtime_frame = None self.noise_frame = None self.help = HelpDoc()
def __init__(self): super(NoiseFrame, self).__init__() self.setupUi(self) self.setWindowTitle('Seismic Ambient Noise') self.setWindowIcon(pqg.QIcon(':\icons\map-icon.png')) # Settings dialog self.settings_dialog = SettingsDialogNoise(self) # Parameters settings self.parameters = ParametersSettings() # Create tabs and add them to tabWidget # TODO: sharing parameters and settings this way. Should they be shared? # Or they are only specific to EGFFrame? self.egf_frame = EGFFrame(self.parameters, self.settings_dialog) self.ft_frame = FrequencyTimeFrame() self.tabWidget.addTab(self.egf_frame, 'EGFs') self.tabWidget.addTab(self.ft_frame, 'Frequency Time Analysis') # Help Documentation self.help = HelpDoc() # Actions self.actionSet_Parameters.triggered.connect( self.open_parameters_settings) self.actionOpen_Settings.triggered.connect(self.settings_dialog.show) # Shortcuts self.shortcut_open = pw.QShortcut(pqg.QKeySequence('Ctrl+L'), self) self.shortcut_open.activated.connect(self.open_parameters_settings)
def __init__(self): super(BaseFrame, self).__init__() self.setupUi(self) self.inventory = {} self.network_list = [] self.stations_list = [] self.catalogBtn.clicked.connect(self.get_catalog) self.event_dataBtn.clicked.connect(self.download_events) self.plotstationsBtn.clicked.connect(self.stations) self.TimeBtn.clicked.connect(self.download_time_series) self.MetadataBtn.clicked.connect(self.download_stations_xml) self.LoadBtn.clicked.connect(self.load_inventory) # Map self.cartopy_canvas = CartopyCanvas(self.map) self.cartopy_canvas.global_map(0) self.cartopy_canvas.figure.subplots_adjust(left=0.00, bottom=0.055, right=0.97, top=0.920, wspace=0.0, hspace=0.0) self.activated_colorbar = True self.cartopy_canvas.on_double_click(self.on_click_matplotlib) self.cartopy_canvas.mpl_connect('key_press_event', self.key_pressed) self.cartopy_canvas.mpl_connect('button_press_event', self.press_right) self.actionOpen_Help.triggered.connect(lambda: self.open_help()) # signal doubleclick self.tableWidget.cellDoubleClicked.connect(self.get_coordinates) # help Documentation self.help = HelpDoc() # self.latitudes = [] self.longitudes = [] self.depths = [] self.magnitudes = []
class TimeFrequencyFrame(BaseFrame, UiTimeFrequencyFrame): def __init__(self): super(TimeFrequencyFrame, self).__init__() self.setupUi(self) self.__stations_dir = None self.__metadata_manager = None self.inventory = {} self._stations_info = {} self.tr1 = [] self.tr2 = [] self.canvas_plot1 = MatplotlibCanvas(self.widget_plot_up, nrows=2) # self.canvas_plot1.set_xlabel(1, "Time (s)") # self.canvas_plot1.set_ylabel(0, "Amplitude ") # self.canvas_plot1.set_ylabel(1, "Frequency (Hz)") self.canvas_plot2 = MatplotlibCanvas(self.widget_plot_down, nrows=2) # self.canvas_plot2.set_xlabel(1, "Time (s)") # self.canvas_plot2.set_ylabel(0, "Amplitude ") # self.canvas_plot2.set_ylabel(1, "Frequency (Hz)") # Binding self.canvas_plot1.mpl_connect('key_press_event', self.key_pressed) self.canvas_plot2.mpl_connect('key_press_event', self.key_pressed) self.root_path_bind = BindPyqtObject(self.rootPathForm, self.onChange_root_path) self.dataless_path_bind = BindPyqtObject(self.datalessPathForm) self.metadata_path_bind = BindPyqtObject(self.datalessPathForm, self.onChange_metadata_path) # Add file selector to the widget self.file_selector = FilesView( self.root_path_bind.value, parent=self.fileSelectorWidget, on_change_file_callback=lambda file_path: self.onChange_file( file_path)) # Binds self.selectDirBtn.clicked.connect( lambda: self.on_click_select_directory(self.root_path_bind)) self.datalessBtn.clicked.connect( lambda: self.on_click_select_file(self.dataless_path_bind)) # Action Buttons self.actionSettings.triggered.connect( lambda: self.open_parameters_settings()) self.actionOpen_Help.triggered.connect(lambda: self.open_help()) self.actionOpen_Spectral_Analysis.triggered.connect( self.time_frequency_advance) self.plotBtn.clicked.connect(self.plot_seismogram) self.stationsBtn.clicked.connect(self.stations_info) # help Documentation self.help = HelpDoc() # Parameters settings self.parameters = ParametersSettings() # Time Frequency Advance #self.time_frequency_advance = TimeFrequencyAdvance() def filter_error_message(self, msg): md = MessageDialog(self) md.set_info_message(msg) def message_dataless_not_found(self): if len(self.dataless_not_found) > 1: md = MessageDialog(self) md.set_info_message("Metadata not found.") else: for file in self.dataless_not_found: md = MessageDialog(self) md.set_info_message("Metadata for {} not found.".format(file)) self.dataless_not_found.clear() def open_parameters_settings(self): self.parameters.show() def time_frequency_advance(self): self._time_frequency_advance = TimeFrequencyAdvance(self.tr1, self.tr2) self._time_frequency_advance.show() def validate_file(self): if not MseedUtil.is_valid_mseed(self.file_selector.file_path): msg = "The file {} is not a valid mseed. Please, choose a valid format". \ format(self.file_selector.file_name) raise InvalidFile(msg) def onChange_root_path(self, value): """ Fired every time the root_path is changed :param value: The path of the new directory. :return: """ self.file_selector.set_new_rootPath(value) def onChange_file(self, file_path): # Called every time user select a different file pass def on_click_select_directory(self, bind: BindPyqtObject): if "darwin" == platform: dir_path = pw.QFileDialog.getExistingDirectory( self, 'Select Directory', bind.value) else: dir_path = pw.QFileDialog.getExistingDirectory( self, 'Select Directory', bind.value, pw.QFileDialog.DontUseNativeDialog) if dir_path: bind.value = dir_path def on_click_select_file(self, bind: BindPyqtObject): selected = pw.QFileDialog.getOpenFileName(self, "Select metadata file") if isinstance(selected[0], str) and os.path.isfile(selected[0]): bind.value = selected[0] def onChange_metadata_path(self, value): md = MessageDialog(self) try: self.__metadata_manager = MetadataManager(value) self.inventory = self.__metadata_manager.get_inventory() md.set_info_message( "Loaded Metadata, please check your terminal for further details" ) except: md.set_error_message( "Something went wrong. Please check your metada file is a correct one" ) @property def trace(self): return ObspyUtil.get_tracer_from_file(self.file_selector.file_path) def get_data(self): file = self.file_selector.file_path starttime = convert_qdatetime_utcdatetime(self.starttime_date) endtime = convert_qdatetime_utcdatetime(self.endtime_date) diff = endtime - starttime parameters = self.parameters.getParameters() sd = SeismogramDataAdvanced(file) if self.trimCB.isChecked() and diff >= 0: tr = sd.get_waveform_advanced( parameters, self.inventory, filter_error_callback=self.filter_error_message, start_time=starttime, end_time=endtime) else: tr = sd.get_waveform_advanced( parameters, self.inventory, filter_error_callback=self.filter_error_message) t = tr.times() return tr, t def get_time_window(self): t1 = convert_qdatetime_utcdatetime(self.starttime_date) t2 = convert_qdatetime_utcdatetime(self.endtime_date) return t1, t2 def stations_info(self): obsfiles = MseedUtil.get_mseed_files(self.root_path_bind.value) obsfiles.sort() sd = [] for file in obsfiles: st = SeismogramDataAdvanced(file) station = [ st.stats.Network, st.stats.Station, st.stats.Location, st.stats.Channel, st.stats.StartTime, st.stats.EndTime, st.stats.Sampling_rate, st.stats.Npts ] sd.append(station) self._stations_info = StationsInfo(sd, check=False) self._stations_info.show() def plot_seismogram(self): selection = self.selectCB.currentText() if selection == "Seismogram 1": #self.validate_file() [self.tr1, t] = self.get_data() self.canvas_plot1.plot(t, self.tr1.data, 0, clear_plot=True, color="black", linewidth=0.5) self.canvas_plot1.set_xlabel(1, "Time (s)") self.canvas_plot1.set_ylabel(0, "Amplitude ") self.canvas_plot1.set_ylabel(1, "Frequency (Hz)") info = "{}.{}.{}".format(self.tr1.stats.network, self.tr1.stats.station, self.tr1.stats.channel) self.canvas_plot1.set_plot_label(0, info) if self.time_frequencyChB.isChecked(): self.time_frequency(self.tr1, selection) if selection == "Seismogram 2": #self.validate_file() [self.tr2, t] = self.get_data() self.canvas_plot2.plot(t, self.tr2.data, 0, clear_plot=True, color="black", linewidth=0.5) self.canvas_plot2.set_xlabel(1, "Time (s)") self.canvas_plot2.set_ylabel(0, "Amplitude ") self.canvas_plot2.set_ylabel(1, "Frequency (Hz)") info = "{}.{}.{}".format(self.tr2.stats.network, self.tr2.stats.station, self.tr2.stats.channel) self.canvas_plot2.set_plot_label(0, info) if self.time_frequencyChB.isChecked(): self.time_frequency(self.tr2, selection) @AsycTime.run_async() def time_frequency(self, tr, order): selection = self.time_frequencyCB.currentText() ts, te = self.get_time_window() diff = te - ts if selection == "Multitaper Spectrogram": win = int(self.mt_window_lengthDB.value() * tr.stats.sampling_rate) tbp = self.time_bandwidth_DB.value() ntapers = self.number_tapers_mtSB.value() f_min = self.freq_min_mtDB.value() f_max = self.freq_max_mtDB.value() mtspectrogram = MTspectrogram(self.file_selector.file_path, win, tbp, ntapers, f_min, f_max) if self.trimCB.isChecked() and diff >= 0: x, y, log_spectrogram = mtspectrogram.compute_spectrogram( tr, start_time=ts, end_time=te) else: x, y, log_spectrogram = mtspectrogram.compute_spectrogram(tr) log_spectrogram = np.clip(log_spectrogram, a_min=self.minlevelCB.value(), a_max=0) min_log_spectrogram = self.minlevelCB.value() max_log_spectrogram = 0 if order == "Seismogram 1": if self.typeCB.currentText() == 'contourf': self.canvas_plot1.plot_contour(x, y, log_spectrogram, axes_index=1, clabel="Power [dB]", cmap=plt.get_cmap("jet"), vmin=min_log_spectrogram, vmax=max_log_spectrogram) elif self.typeCB.currentText() == 'pcolormesh': print("plotting pcolormesh") self.canvas_plot1.pcolormesh(x, y, log_spectrogram, axes_index=1, clabel="Power [dB]", cmap=plt.get_cmap("jet"), vmin=min_log_spectrogram, vmax=max_log_spectrogram) self.canvas_plot1.set_xlabel(1, "Time (s)") self.canvas_plot1.set_ylabel(0, "Amplitude ") self.canvas_plot1.set_ylabel(1, "Frequency (Hz)") elif order == "Seismogram 2": if self.typeCB.currentText() == 'contourf': self.canvas_plot2.plot_contour(x, y, log_spectrogram, axes_index=1, clear_plot=True, clabel="Power [dB]", cmap=plt.get_cmap("jet"), vmin=min_log_spectrogram, vmax=max_log_spectrogram) elif self.typeCB.currentText() == 'pcolormesh': self.canvas_plot2.pcolormesh(x, y, log_spectrogram, axes_index=1, clear_plot=True, clabel="Power [dB]", cmap=plt.get_cmap("jet"), vmin=min_log_spectrogram, vmax=max_log_spectrogram) self.canvas_plot2.set_xlabel(1, "Time (s)") self.canvas_plot2.set_ylabel(0, "Amplitude ") self.canvas_plot2.set_ylabel(1, "Frequency (Hz)") elif selection == "Wigner Spectrogram": win = int(self.mt_window_lengthDB.value() * tr.stats.sampling_rate) tbp = self.time_bandwidth_DB.value() ntapers = self.number_tapers_mtSB.value() f_min = self.freq_min_mtDB.value() f_max = self.freq_max_mtDB.value() wignerspec = WignerVille(self.file_selector.file_path, win, tbp, ntapers, f_min, f_max) if self.trimCB.isChecked() and diff >= 0: x, y, log_spectrogram = wignerspec.compute_wigner_spectrogram( tr, start_time=ts, end_time=te) else: x, y, log_spectrogram = wignerspec.compute_wigner_spectrogram( tr) if order == "Seismogram 1": if self.typeCB.currentText() == 'contourf': self.canvas_plot1.plot_contour(x, y, log_spectrogram, axes_index=1, clear_plot=True, clabel="Rel Power ", cmap=plt.get_cmap("jet")) elif self.typeCB.currentText() == 'pcolormesh': self.canvas_plot1.pcolormesh(x, y, log_spectrogram, axes_index=1, clear_plot=True, clabel="Rel Power ", cmap=plt.get_cmap("jet")) self.canvas_plot1.set_xlabel(1, "Time (s)") self.canvas_plot1.set_ylabel(0, "Amplitude ") self.canvas_plot1.set_ylabel(1, "Frequency (Hz)") elif order == "Seismogram 2": if self.typeCB.currentText() == 'contourf': self.canvas_plot2.plot_contour(x, y, log_spectrogram, axes_index=1, clear_plot=True, clabel="Power [dB]", cmap=plt.get_cmap("jet")) elif self.typeCB.currentText() == 'pcolormesh': self.canvas_plot2.pcolormesh(x, y, log_spectrogram, axes_index=1, clear_plot=True, clabel="Power [dB]", cmap=plt.get_cmap("jet")) self.canvas_plot2.set_xlabel(1, "Time (s)") self.canvas_plot2.set_ylabel(0, "Amplitude ") self.canvas_plot2.set_ylabel(1, "Frequency (Hz)") elif selection == "Continuous Wavelet Transform": fs = tr.stats.sampling_rate nf = self.atomsSB.value() f_min = self.freq_min_cwtDB.value() f_max = self.freq_max_cwtDB.value() wmin = self.wminSB.value() wmax = self.wminSB.value() #tt = int( self.wavelet_lenghtDB.value()*fs) npts = len(tr.data) t = np.linspace(0, tr.stats.delta * npts, npts) #cw = ConvolveWaveletScipy(self.file_selector.file_path) cw = ConvolveWaveletScipy(tr) wavelet = self.wavelet_typeCB.currentText() m = self.wavelets_param.value() if self.trimCB.isChecked() and diff >= 0: cw.setup_wavelet(ts, te, wmin=wmin, wmax=wmax, tt=int(fs / f_min), fmin=f_min, fmax=f_max, nf=nf, use_wavelet=wavelet, m=m, decimate=False) else: cw.setup_wavelet(wmin=wmin, wmax=wmax, tt=int(fs / f_min), fmin=f_min, fmax=f_max, nf=nf, use_wavelet=wavelet, m=m, decimate=False) scalogram2 = cw.scalogram_in_dbs() scalogram2 = np.clip(scalogram2, a_min=self.minlevelCB.value(), a_max=0) cf = cw.cf_lowpass() freq = np.logspace(np.log10(f_min), np.log10(f_max)) k = wmin / (2 * np.pi * freq) delay = int(fs * np.mean(k)) x, y = np.meshgrid( t, np.logspace(np.log10(f_min), np.log10(f_max), scalogram2.shape[0])) c_f = wmin / 2 * math.pi f = np.linspace((f_min), (f_max), scalogram2.shape[0]) pred = (math.sqrt(2) * c_f / f) - (math.sqrt(2) * c_f / f_max) pred_comp = t[len(t) - 1] - pred min_cwt = self.minlevelCB.value() max_cwt = 0 norm = Normalize(vmin=min_cwt, vmax=max_cwt) tf = t[delay:len(t)] cf = cf[0:len(tf)] if order == "Seismogram 1": #self.canvas_plot1.plot(tf, cf, 0, clear_plot=True, is_twinx=True, color="red", # linewidth=0.5) if self.typeCB.currentText() == 'pcolormesh': self.canvas_plot1.pcolormesh(x, y, scalogram2, axes_index=1, clear_plot=True, clabel="Power [dB]", cmap=plt.get_cmap("jet"), vmin=min_cwt, vmax=max_cwt) elif self.typeCB.currentText() == 'contourf': self.canvas_plot1.plot_contour(x, y, scalogram2, axes_index=1, clear_plot=True, clabel="Power [dB]", cmap=plt.get_cmap("jet"), vmin=min_cwt, vmax=max_cwt) ax_cone = self.canvas_plot1.get_axe(1) ax_cone.fill_between(pred, f, 0, color="black", edgecolor="red", alpha=0.3) ax_cone.fill_between(pred_comp, f, 0, color="black", edgecolor="red", alpha=0.3) self.canvas_plot1.set_xlabel(1, "Time (s)") self.canvas_plot1.set_ylabel(0, "Amplitude ") self.canvas_plot1.set_ylabel(1, "Frequency (Hz)") if order == "Seismogram 2": #self.canvas_plot2.plot(tf, cf, 0, clear_plot=True, is_twinx=True, color="red", # linewidth=0.5) if self.typeCB.currentText() == 'pcolormesh': self.canvas_plot2.pcolormesh(x, y, scalogram2, axes_index=1, clear_plot=True, clabel="Power [dB]", cmap=plt.get_cmap("jet"), vmin=min_cwt, vmax=max_cwt) elif self.typeCB.currentText() == 'contourf': self.canvas_plot2.plot_contour(x, y, scalogram2, axes_index=1, clear_plot=True, clabel="Power [dB]", cmap=plt.get_cmap("jet"), vmin=min_cwt, vmax=max_cwt) ax_cone2 = self.canvas_plot2.get_axe(1) ax_cone2.fill_between(pred, f, 0, color="black", edgecolor="red", alpha=0.3) ax_cone2.fill_between(pred_comp, f, 0, color="black", edgecolor="red", alpha=0.3) self.canvas_plot2.set_xlabel(1, "Time (s)") self.canvas_plot2.set_ylabel(0, "Amplitude ") self.canvas_plot2.set_ylabel(1, "Frequency (Hz)") else: pass def key_pressed(self, event): selection = self.selectCB.currentText() if event.key == 'w': self.plot_seismogram() if event.key == 'q': if selection == "Seismogram 1": [tr, t] = self.get_data() x1, y1 = event.xdata, event.ydata tt = tr.stats.starttime + x1 set_qdatetime(tt, self.starttime_date) self.canvas_plot1.draw_arrow(x1, 0, arrow_label="st", color="purple", linestyles='--', picker=False) elif selection == "Seismogram 2": [tr, t] = self.get_data() x1, y1 = event.xdata, event.ydata tt = tr.stats.starttime + x1 set_qdatetime(tt, self.starttime_date) self.canvas_plot2.draw_arrow(x1, 0, arrow_label="st", color="purple", linestyles='--', picker=False) if event.key == 'e': if selection == "Seismogram 1": [tr, t] = self.get_data() x1, y1 = event.xdata, event.ydata tt = tr.stats.starttime + x1 set_qdatetime(tt, self.endtime_date) self.canvas_plot1.draw_arrow(x1, 0, arrow_label="et", color="purple", linestyles='--', picker=False) elif selection == "Seismogram 2": [tr, t] = self.get_data() x1, y1 = event.xdata, event.ydata tt = tr.stats.starttime + x1 set_qdatetime(tt, self.endtime_date) self.canvas_plot2.draw_arrow(x1, 0, arrow_label="et", color="purple", linestyles='--', picker=False) def open_help(self): self.help.show()
def __init__(self): super(RealTimeFrame, self).__init__() self.setupUi(self) self.setWindowIcon(pqg.QIcon(':\\icons\\map-icon.png')) self.widget_map = None self.settings_dialog = SettingsDialog(self) self.inventory = {} self.files = [] self.events_times = [] self.total_items = 0 self.items_per_page = 1 self.__dataless_manager = None self.__metadata_manager = None self.st = None self.client = None self.stations_available = [] self.data_dict = {} self.dataless_not_found = set( ) # a set of mseed files that the dataless couldn't find. self.metadata_path_bind = BindPyqtObject(self.datalessPathForm, self.onChange_metadata_path) self.canvas = MatplotlibCanvas(self.plotMatWidget, nrows=self.numTracesCB.value(), constrained_layout=False) self.canvas.figure.tight_layout() self.timer_outdated = pyc.QTimer() self.timer_outdated.setInterval(1000) # 1 second self.timer_outdated.timeout.connect(self.outdated_stations) # Binding self.root_path_bind = BindPyqtObject(self.rootPathForm) self.dataless_path_bind = BindPyqtObject(self.datalessPathForm) # Bind self.selectDirBtn.clicked.connect( lambda: self.on_click_select_directory(self.root_path_bind)) #self.selectDatalessDirBtn.clicked.connect(lambda: self.on_click_select_directory(self.dataless_path_bind)) self.metadata_path_bind = BindPyqtObject(self.datalessPathForm, self.onChange_metadata_path) self.selectDatalessDirBtn.clicked.connect( lambda: self.on_click_select_metadata_file(self.metadata_path_bind )) self.actionSet_Parameters.triggered.connect( lambda: self.open_parameters_settings()) self.mapBtn.clicked.connect(self.show_map) # self.__metadata_manager = MetadataManager(self.dataless_path_bind.value) self.actionSet_Parameters.triggered.connect( lambda: self.open_parameters_settings()) self.actionArray_Anlysis.triggered.connect(self.open_array_analysis) self.actionMoment_Tensor_Inversion.triggered.connect( self.open_moment_tensor) self.actionTime_Frequency_Analysis.triggered.connect( self.time_frequency_analysis) self.actionReceiver_Functions.triggered.connect( self.open_receiver_functions) self.actionOpen_Settings.triggered.connect( lambda: self.settings_dialog.show()) self.actionOpen_Help.triggered.connect(lambda: self.open_help()) self.RetrieveBtn.clicked.connect(self.retrieve_data) self.stopBtn.clicked.connect(self.stop) # Parameters settings self.parameters = ParametersSettings() # Earth Model Viewer self.earthmodel = EarthModelViewer() # help Documentation self.help = HelpDoc()
def __init__(self): super(ArrayAnalysisFrame, self).__init__() self.setupUi(self) self.__stations_dir = None self.stream_frame = None self.__metadata_manager = None self.inventory = {} self._stations_info = {} self._stations_coords = {} self.stack = None self.canvas = MatplotlibCanvas(self.responseMatWidget) self.canvas_fk = MatplotlibCanvas(self.widget_fk, nrows=4) self.canvas_slow_map = MatplotlibCanvas(self.widget_slow_map) self.canvas_fk.on_double_click(self.on_click_matplotlib) self.canvas_stack = MatplotlibCanvas(self.widget_stack) self.cartopy_canvas = CartopyCanvas(self.widget_map) self.canvas.set_new_subplot(1, ncols=1) #Binding self.root_pathFK_bind = BindPyqtObject(self.rootPathFormFK) self.root_pathBP_bind = BindPyqtObject(self.rootPathFormBP) self.metadata_path_bind = BindPyqtObject(self.datalessPathForm, self.onChange_metadata_path) self.metadata_path_bindBP = BindPyqtObject(self.datalessPathFormBP, self.onChange_metadata_path) self.output_path_bindBP = BindPyqtObject(self.outputPathFormBP, self.onChange_metadata_path) self.fmin_bind = BindPyqtObject(self.fminSB) self.fmax_bind = BindPyqtObject(self.fmaxSB) self.grid_bind = BindPyqtObject(self.gridSB) self.smax_bind = BindPyqtObject(self.smaxSB) # On select self.canvas_fk.register_on_select(self.on_select, rectprops=dict(alpha=0.2, facecolor='red')) self.fminFK_bind = BindPyqtObject(self.fminFKSB) self.fmaxFK_bind = BindPyqtObject(self.fmaxFKSB) self.overlap_bind = BindPyqtObject(self.overlapSB) self.timewindow_bind = BindPyqtObject(self.timewindowSB) self.smaxFK_bind = BindPyqtObject(self.slowFKSB) self.slow_grid_bind = BindPyqtObject(self.gridFKSB) # Bind buttons self.selectDirBtnFK.clicked.connect( lambda: self.on_click_select_directory(self.root_pathFK_bind)) self.datalessBtn.clicked.connect( lambda: self.on_click_select_metadata_file(self.metadata_path_bind )) # Bind buttons BackProjection self.selectDirBtnBP.clicked.connect( lambda: self.on_click_select_directory(self.root_pathBP_bind)) self.datalessBtnBP.clicked.connect( lambda: self.on_click_select_metadata_file(self. metadata_path_bindBP)) self.outputBtn.clicked.connect( lambda: self.on_click_select_directory(self.output_path_bindBP)) #Action Buttons self.arfBtn.clicked.connect(lambda: self.arf()) self.runFKBtn.clicked.connect(lambda: self.FK_plot()) self.plotBtn.clicked.connect(lambda: self.plot_seismograms()) self.plotBtnBP.clicked.connect(lambda: self.plot_seismograms(FK=False)) self.actionSettings.triggered.connect( lambda: self.open_parameters_settings()) self.actionProcessed_Seimograms.triggered.connect(self.write) self.actionStacked_Seismograms.triggered.connect(self.write_stack) self.stationsBtn.clicked.connect(lambda: self.stationsInfo()) self.stationsBtnBP.clicked.connect(lambda: self.stationsInfo(FK=False)) self.mapBtn.clicked.connect(self.stations_map) self.actionCreate_Stations_File.triggered.connect( self.stations_coordinates) self.actionLoad_Stations_File.triggered.connect(self.load_path) self.actionRunVespagram.triggered.connect(self.open_vespagram) self.shortcut_open = pw.QShortcut(pqg.QKeySequence('Ctrl+O'), self) self.shortcut_open.activated.connect(self.open_solutions) self.create_gridBtn.clicked.connect(self.create_grid) self.actionOpen_Help.triggered.connect(lambda: self.open_help()) self.load_videoBtn.clicked.connect(self.loadvideoBP) # help Documentation self.help = HelpDoc() # Parameters settings self.__parameters = ParametersSettings() # Stations Coordinates self.__stations_coords = StationsCoords() # picks self.picks = { 'Time': [], 'Phase': [], 'BackAzimuth': [], 'Slowness': [], 'Power': [] } # video self.player = QMediaPlayer(None, QMediaPlayer.VideoSurface) self.player.setVideoOutput(self.backprojection_widget) self.player.stateChanged.connect(self.mediaStateChanged) self.player.positionChanged.connect(self.positionChanged) self.player.durationChanged.connect(self.durationChanged) self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay)) self.playButton.clicked.connect(self.play_bp) self.positionSlider.sliderMoved.connect(self.setPosition)
class ArrayAnalysisFrame(BaseFrame, UiArrayAnalysisFrame): def __init__(self): super(ArrayAnalysisFrame, self).__init__() self.setupUi(self) self.__stations_dir = None self.stream_frame = None self.__metadata_manager = None self.inventory = {} self._stations_info = {} self._stations_coords = {} self.stack = None self.canvas = MatplotlibCanvas(self.responseMatWidget) self.canvas_fk = MatplotlibCanvas(self.widget_fk, nrows=4) self.canvas_slow_map = MatplotlibCanvas(self.widget_slow_map) self.canvas_fk.on_double_click(self.on_click_matplotlib) self.canvas_stack = MatplotlibCanvas(self.widget_stack) self.cartopy_canvas = CartopyCanvas(self.widget_map) self.canvas.set_new_subplot(1, ncols=1) #Binding self.root_pathFK_bind = BindPyqtObject(self.rootPathFormFK) self.root_pathBP_bind = BindPyqtObject(self.rootPathFormBP) self.metadata_path_bind = BindPyqtObject(self.datalessPathForm, self.onChange_metadata_path) self.metadata_path_bindBP = BindPyqtObject(self.datalessPathFormBP, self.onChange_metadata_path) self.output_path_bindBP = BindPyqtObject(self.outputPathFormBP, self.onChange_metadata_path) self.fmin_bind = BindPyqtObject(self.fminSB) self.fmax_bind = BindPyqtObject(self.fmaxSB) self.grid_bind = BindPyqtObject(self.gridSB) self.smax_bind = BindPyqtObject(self.smaxSB) # On select self.canvas_fk.register_on_select(self.on_select, rectprops=dict(alpha=0.2, facecolor='red')) self.fminFK_bind = BindPyqtObject(self.fminFKSB) self.fmaxFK_bind = BindPyqtObject(self.fmaxFKSB) self.overlap_bind = BindPyqtObject(self.overlapSB) self.timewindow_bind = BindPyqtObject(self.timewindowSB) self.smaxFK_bind = BindPyqtObject(self.slowFKSB) self.slow_grid_bind = BindPyqtObject(self.gridFKSB) # Bind buttons self.selectDirBtnFK.clicked.connect( lambda: self.on_click_select_directory(self.root_pathFK_bind)) self.datalessBtn.clicked.connect( lambda: self.on_click_select_metadata_file(self.metadata_path_bind )) # Bind buttons BackProjection self.selectDirBtnBP.clicked.connect( lambda: self.on_click_select_directory(self.root_pathBP_bind)) self.datalessBtnBP.clicked.connect( lambda: self.on_click_select_metadata_file(self. metadata_path_bindBP)) self.outputBtn.clicked.connect( lambda: self.on_click_select_directory(self.output_path_bindBP)) #Action Buttons self.arfBtn.clicked.connect(lambda: self.arf()) self.runFKBtn.clicked.connect(lambda: self.FK_plot()) self.plotBtn.clicked.connect(lambda: self.plot_seismograms()) self.plotBtnBP.clicked.connect(lambda: self.plot_seismograms(FK=False)) self.actionSettings.triggered.connect( lambda: self.open_parameters_settings()) self.actionProcessed_Seimograms.triggered.connect(self.write) self.actionStacked_Seismograms.triggered.connect(self.write_stack) self.stationsBtn.clicked.connect(lambda: self.stationsInfo()) self.stationsBtnBP.clicked.connect(lambda: self.stationsInfo(FK=False)) self.mapBtn.clicked.connect(self.stations_map) self.actionCreate_Stations_File.triggered.connect( self.stations_coordinates) self.actionLoad_Stations_File.triggered.connect(self.load_path) self.actionRunVespagram.triggered.connect(self.open_vespagram) self.shortcut_open = pw.QShortcut(pqg.QKeySequence('Ctrl+O'), self) self.shortcut_open.activated.connect(self.open_solutions) self.create_gridBtn.clicked.connect(self.create_grid) self.actionOpen_Help.triggered.connect(lambda: self.open_help()) self.load_videoBtn.clicked.connect(self.loadvideoBP) # help Documentation self.help = HelpDoc() # Parameters settings self.__parameters = ParametersSettings() # Stations Coordinates self.__stations_coords = StationsCoords() # picks self.picks = { 'Time': [], 'Phase': [], 'BackAzimuth': [], 'Slowness': [], 'Power': [] } # video self.player = QMediaPlayer(None, QMediaPlayer.VideoSurface) self.player.setVideoOutput(self.backprojection_widget) self.player.stateChanged.connect(self.mediaStateChanged) self.player.positionChanged.connect(self.positionChanged) self.player.durationChanged.connect(self.durationChanged) self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay)) self.playButton.clicked.connect(self.play_bp) self.positionSlider.sliderMoved.connect(self.setPosition) def mediaStateChanged(self): if self.player.state() == QMediaPlayer.PlayingState: self.playButton.setIcon(self.style().standardIcon( QStyle.SP_MediaPause)) else: self.playButton.setIcon(self.style().standardIcon( QStyle.SP_MediaPlay)) def positionChanged(self, position): self.positionSlider.setValue(position) def durationChanged(self, duration): self.positionSlider.setRange(0, duration) def setPosition(self, position): self.player.setPosition(position) def open_parameters_settings(self): self.__parameters.show() def stations_coordinates(self): self.__stations_coords.show() def open_vespagram(self): if self.st and self.inventory and self.t1 and self.t2: self.__vespagram = Vespagram(self.st, self.inventory, self.t1, self.t2) self.__vespagram.show() def on_click_select_directory(self, bind: BindPyqtObject): if "darwin" == platform: dir_path = pw.QFileDialog.getExistingDirectory( self, 'Select Directory', bind.value) else: dir_path = pw.QFileDialog.getExistingDirectory( self, 'Select Directory', bind.value, pw.QFileDialog.DontUseNativeDialog) if dir_path: bind.value = dir_path def onChange_metadata_path(self, value): md = MessageDialog(self) try: self.__metadata_manager = MetadataManager(value) self.inventory = self.__metadata_manager.get_inventory() print(self.inventory) md.set_info_message( "Loaded Metadata, please check your terminal for further details" ) except: md.set_error_message( "Something went wrong. Please check your metada file is a correct one" ) def on_click_select_metadata_file(self, bind: BindPyqtObject): selected = pw.QFileDialog.getOpenFileName(self, "Select metadata file") if isinstance(selected[0], str) and os.path.isfile(selected[0]): bind.value = selected[0] def load_path(self): selected_file = pw.QFileDialog.getOpenFileName( self, "Select Stations Coordinates file") self.path_file = selected_file[0] df = pd.read_csv(self.path_file, delim_whitespace=True) n = len(df) self.coords = np.zeros([n, 3]) for i in range(n): #coords[i]=data[i] self.coords[i] = np.array( [df['Lon'][i], df['Lat'][i], df['Depth'][i]]) def arf(self): try: if self.coords.all(): wavenumber = array_analysis.array() arf = wavenumber.arf(self.coords, self.fmin_bind.value, self.fmax_bind.value, self.smax_bind.value, self.grid_bind.value) slim = self.smax_bind.value x = y = np.linspace(-1 * slim, slim, len(arf)) self.canvas.plot_contour(x, y, arf, axes_index=0, clabel="Power [dB]", cmap=plt.get_cmap("jet")) self.canvas.set_xlabel(0, "Sx (s/km)") self.canvas.set_ylabel(0, "Sy (s/km)") except: md = MessageDialog(self) md.set_error_message( "Couldn't compute ARF, please check if you have loaded stations coords" ) def stations_map(self): coords = {} if self.path_file: df = pd.read_csv(self.path_file, delim_whitespace=True) n = len(df) self.coords = np.zeros([n, 3]) for i in range(n): coords[df['Name'][i]] = [ df['Lat'][i], df['Lon'][i], ] #try: self.cartopy_canvas.plot_map(df['Lat'][0], df['Lon'][0], 0, 0, 0, 0, resolution="low", stations=coords) #except: # pass def FK_plot(self): self.canvas_stack.set_new_subplot(nrows=1, ncols=1) starttime = convert_qdatetime_utcdatetime(self.starttime_date) endtime = convert_qdatetime_utcdatetime(self.endtime_date) selection = self.inventory.select(station=self.stationLE.text(), channel=self.channelLE.text()) if self.trimCB.isChecked(): wavenumber = array_analysis.array() relpower, abspower, AZ, Slowness, T = wavenumber.FK( self.st, selection, starttime, endtime, self.fminFK_bind.value, self.fmaxFK_bind.value, self.smaxFK_bind.value, self.slow_grid_bind.value, self.timewindow_bind.value, self.overlap_bind.value) self.canvas_fk.scatter3d(T, relpower, relpower, axes_index=0, clabel="Power [dB]") self.canvas_fk.scatter3d(T, abspower, relpower, axes_index=1, clabel="Power [dB]") self.canvas_fk.scatter3d(T, AZ, relpower, axes_index=2, clabel="Power [dB]") self.canvas_fk.scatter3d(T, Slowness, relpower, axes_index=3, clabel="Power [dB]") self.canvas_fk.set_ylabel(0, " Rel Power ") self.canvas_fk.set_ylabel(1, " Absolute Power ") self.canvas_fk.set_ylabel(2, " Back Azimuth ") self.canvas_fk.set_ylabel(3, " Slowness [s/km] ") self.canvas_fk.set_xlabel(3, " Time [s] ") ax = self.canvas_fk.get_axe(3) formatter = mdt.DateFormatter('%H:%M:%S') ax.xaxis.set_major_formatter(formatter) ax.xaxis.set_tick_params(rotation=30) else: md = MessageDialog(self) md.set_info_message("Please select dates and then check Trim box") def on_click_matplotlib(self, event, canvas): output_path = os.path.join(ROOT_DIR, 'arrayanalysis', 'dataframe.csv') if isinstance(canvas, MatplotlibCanvas): st = self.st.copy() wavenumber = array_analysis.array() selection = self.inventory.select(station=self.stationLE.text(), channel=self.channelLE.text()) x1, y1 = event.xdata, event.ydata DT = x1 Z, Sxpow, Sypow, coord = wavenumber.FKCoherence( st, selection, DT, self.fminFK_bind.value, self.fmaxFK_bind.value, self.smaxFK_bind.value, self.timewindow_bind.value, self.slow_grid_bind.value, self.methodSB.currentText()) backacimuth = wavenumber.azimuth2mathangle( np.arctan2(Sypow, Sxpow) * 180 / np.pi) slowness = np.abs(Sxpow, Sypow) if self.methodSB.currentText() == "FK": clabel = "Power" elif self.methodSB.currentText() == "MTP.COHERENCE": clabel = "Magnitude Coherence" Sx = np.arange(-1 * self.smaxFK_bind.value, self.smaxFK_bind.value, self.slow_grid_bind.value)[np.newaxis] nx = len(Sx[0]) x = y = np.linspace(-1 * self.smaxFK_bind.value, self.smaxFK_bind.value, nx) X, Y = np.meshgrid(x, y) self.canvas_slow_map.plot_contour(X, Y, Z, axes_index=0, clabel=clabel, cmap=plt.get_cmap("jet")) self.canvas_slow_map.set_xlabel(0, "Sx [s/km]") self.canvas_slow_map.set_ylabel(0, "Sy [s/km]") # Save in a dataframe the pick value x1 = wavenumber.gregorian2date(x1) self.picks['Time'].append(x1.isoformat()) self.picks['Phase'].append(self.phaseCB.currentText()) self.picks['BackAzimuth'].append(backacimuth[0]) self.picks['Slowness'].append(slowness[0]) self.picks['Power'].append(np.max(Z)) df = pd.DataFrame(self.picks) df.to_csv(output_path, index=False, header=True) # Call Stack and Plot### #stream_stack, time = wavenumber.stack_stream(self.root_pathFK_bind.value, Sxpow, Sypow, coord) if st: st2 = self.st.copy() # Align for the maximum power and give the data of the traces stream_stack, self.time, self.stats = wavenumber.stack_stream( st2, Sxpow, Sypow, coord) # stack the traces self.stack = wavenumber.stack( stream_stack, stack_type=self.stackCB.currentText()) self.canvas_stack.plot(self.time, self.stack, axes_index=0, linewidth=0.75) self.canvas_stack.set_xlabel(0, " Time [s] ") self.canvas_stack.set_ylabel(0, "Stack Amplitude") def filter_error_message(self, msg): md = MessageDialog(self) md.set_info_message(msg) def plot_seismograms(self, FK=True): if FK: starttime = convert_qdatetime_utcdatetime(self.starttime_date) endtime = convert_qdatetime_utcdatetime(self.endtime_date) else: starttime = convert_qdatetime_utcdatetime(self.starttime_date_BP) endtime = convert_qdatetime_utcdatetime(self.endtime_date_BP) diff = endtime - starttime if FK: file_path = self.root_pathFK_bind.value else: file_path = self.root_pathBP_bind.value obsfiles = [] for dirpath, _, filenames in os.walk(file_path): for f in filenames: if f != ".DS_Store": obsfiles.append(os.path.abspath(os.path.join(dirpath, f))) obsfiles.sort() parameters = self.__parameters.getParameters() all_traces = [] trace_number = 0 for file in obsfiles: sd = SeismogramDataAdvanced(file) if FK: if self.trimCB.isChecked() and diff >= 0: tr = sd.get_waveform_advanced( parameters, self.inventory, filter_error_callback=self.filter_error_message, start_time=starttime, end_time=endtime, trace_number=trace_number) else: tr = sd.get_waveform_advanced( parameters, self.inventory, filter_error_callback=self.filter_error_message, trace_number=trace_number) else: if self.trimCB_BP.isChecked() and diff >= 0: tr = sd.get_waveform_advanced( parameters, self.inventory, filter_error_callback=self.filter_error_message, start_time=starttime, end_time=endtime, trace_number=trace_number) else: tr = sd.get_waveform_advanced( parameters, self.inventory, filter_error_callback=self.filter_error_message, trace_number=trace_number) all_traces.append(tr) trace_number = trace_number + 1 self.st = Stream(traces=all_traces) if FK: if self.selectCB.isChecked(): self.st = self.st.select(station=self.stationLE.text(), channel=self.channelLE.text()) else: if self.selectCB_BP.isChecked(): self.st = self.st.select(network=self.stationLE_BP.text(), station=self.stationLE_BP.text(), channel=self.channelLE_BP.text()) self.stream_frame = MatplotlibFrame(self.st, type='normal') self.stream_frame.show() def stationsInfo(self, FK=True): if FK: obsfiles = MseedUtil.get_mseed_files(self.root_pathFK_bind.value) else: obsfiles = MseedUtil.get_mseed_files(self.root_pathBP_bind.value) obsfiles.sort() sd = [] for file in obsfiles: st = SeismogramDataAdvanced(file) station = [ st.stats.Network, st.stats.Station, st.stats.Location, st.stats.Channel, st.stats.StartTime, st.stats.EndTime, st.stats.Sampling_rate, st.stats.Npts ] sd.append(station) self._stations_info = StationsInfo(sd, check=True) self._stations_info.show() def write(self): root_path = os.path.dirname(os.path.abspath(__file__)) if "darwin" == platform: dir_path = pw.QFileDialog.getExistingDirectory( self, 'Select Directory', root_path) else: dir_path = pw.QFileDialog.getExistingDirectory( self, 'Select Directory', root_path, pw.QFileDialog.DontUseNativeDialog) if dir_path: n = len(self.st) try: if len(n) > 0: for j in range(n): tr = self.st[j] t1 = tr.stats.starttime id = tr.id + "." + "D" + "." + str( t1.year) + "." + str(t1.julday) print(tr.id, "Writing data processed") path_output = os.path.join(dir_path, id) tr.write(path_output, format="MSEED") else: md = MessageDialog(self) md.set_info_message("Nothing to write") except: pass def write_stack(self): if self.stack is not None and len(self.stack) > 0: root_path = os.path.dirname(os.path.abspath(__file__)) if "darwin" == platform: dir_path = pw.QFileDialog.getExistingDirectory( self, 'Select Directory', root_path) else: dir_path = pw.QFileDialog.getExistingDirectory( self, 'Select Directory', root_path, pw.QFileDialog.DontUseNativeDialog) if dir_path: tr = Trace(data=self.stack, header=self.stats) file = os.path.join(dir_path, tr.id) tr.write(file, format="MSEED") else: md = MessageDialog(self) md.set_info_message("Nothing to write") def __to_UTC(self, DT): # Convert start from Greogorian to actual date Time = DT Time = Time - int(Time) d = date.fromordinal(int(DT)) date1 = d.isoformat() H = (Time * 24) H1 = int(H) # Horas minutes = (H - int(H)) * 60 minutes1 = int(minutes) seconds = (minutes - int(minutes)) * 60 H1 = str(H1).zfill(2) minutes1 = str(minutes1).zfill(2) seconds = "%.2f" % seconds seconds = str(seconds).zfill(2) DATE = date1 + "T" + str(H1) + minutes1 + seconds t1 = UTCDateTime(DATE) return t1 def on_select(self, ax_index, xmin, xmax): self.t1 = self.__to_UTC(xmin) self.t2 = self.__to_UTC(xmax) def open_solutions(self): output_path = os.path.join(ROOT_DIR, 'arrayanalysis', 'dataframe.csv') try: command = "{} {}".format('open', output_path) exc_cmd(command, cwd=ROOT_DIR) except: md = MessageDialog(self) md.set_error_message("Coundn't open solutions file") ### New part back-projection def create_grid(self): area_coords = [ self.minLonBP, self.maxLonBP, self.minLatBP, self.maxLatBP ] bp = back_proj_organize(self, self.rootPathFormBP, self.datalessPathFormBP, area_coords, self.sxSB.value, self.sxSB.value, self.depthSB.value) mapping = bp.create_dict() try: self.path_file = os.path.join(self.output_path_bindBP.value, "mapping.pkl") file_to_store = open(self.path_file, "wb") pickle.dump(mapping, file_to_store) md = MessageDialog(self) md.set_info_message("BackProjection grid created succesfully!!!") except: md = MessageDialog(self) md.set_error_message("Coundn't create a BackProjection grid") def run_bp(self): try: if os.path.exists(self.path_file): with open(self.path_file, 'rb') as handle: mapping = pickle.load(handle) except: md = MessageDialog(self) md.set_error_message( "Please you need try to previously create a BackProjection grid" ) power = backproj.run_back(self.st, mapping, self.time_winBP.value, self.stepBP.value, window=self.slide_winBP.value, multichannel=self.mcccCB.isChecked(), stack_process=self.methodBP.currentText()) #plot_cum(power, mapping['area_coords'], self.cum_sumBP.value, self.st) plot_bp(power, mapping['area_coords'], self.cum_sumBP.value, self.st, output=self.output_path_bindBP.value) fname = os.path.join(self.output_path_bindBP.value, "power.pkl") file_to_store = open(fname, "wb") pickle.dump(power, file_to_store) def loadvideoBP(self): self.path_video, _ = pw.QFileDialog.getOpenFileName( self, "Choose your BackProjection", ".", "Video Files (*.mp4 *.flv *.ts *.mts *.avi)") if self.path_video != '': self.player.setVideoOutput(self.backprojection_widget) self.player.setMedia( QMediaContent(pyc.QUrl.fromLocalFile(self.path_video))) md = MessageDialog(self) md.set_info_message( "Video containing BackProjection succesfully loaded") else: md = MessageDialog(self) md.set_error_message( "Video containing BackProjection couldn't be loaded") def play_bp(self): if self.player.state() == QMediaPlayer.PlayingState: self.player.pause() else: self.player.play() def open_help(self): self.help.show()
class MTIFrame(BaseFrame, UiMomentTensor): def __init__(self): super(MTIFrame, self).__init__() self.setupUi(self) #super(MTIFrame, self).__init__() self.setupUi(self) self.__stations_dir = None self.__metadata_manager = None self.inventory = {} self._stations_info = {} self.stream = None # Binding self.root_path_bind = BindPyqtObject(self.rootPathForm) #self.dataless_path_bind = BindPyqtObject(self.datalessPathForm) self.metadata_path_bind = BindPyqtObject(self.datalessPathForm, self.onChange_metadata_path) self.earth_path_bind = BindPyqtObject(self.earth_modelPathForm) # Binds self.selectDirBtn.clicked.connect( lambda: self.on_click_select_directory(self.root_path_bind)) self.datalessBtn.clicked.connect( lambda: self.on_click_select_metadata_file(self.metadata_path_bind )) self.earthmodelBtn.clicked.connect( lambda: self.on_click_select_file(self.earth_path_bind)) # Action Buttons self.actionSettings.triggered.connect( lambda: self.open_parameters_settings()) self.plotBtn.clicked.connect(self.plot_seismograms) self.actionSettings.triggered.connect( lambda: self.open_parameters_settings()) self.actionWrite.triggered.connect(self.write) self.actionEarth_Model.triggered.connect( lambda: self.open_earth_model()) self.actionFrom_File.triggered.connect( lambda: self.load_event_from_isolapath()) self.actionOpen_Help.triggered.connect(lambda: self.open_help()) self.stationsBtn.clicked.connect(self.stationsInfo) self.run_inversionBtn.clicked.connect(lambda: self.run_inversion()) self.stations_mapBtn.clicked.connect(lambda: self.plot_map_stations()) self.plot_solutionBtn.clicked.connect(lambda: self.plot_solution()) #self.earthmodelBtn.clicked.connect(self.read_earth_model) # Parameters settings self.parameters = ParametersSettings() self.earth_model = CrustalModelParametersFrame() # help Documentation self.help = HelpDoc() def open_parameters_settings(self): self.parameters.show() def open_earth_model(self): self.earth_model.show() def filter_error_message(self, msg): md = MessageDialog(self) md.set_info_message(msg) def message_dataless_not_found(self): if len(self.dataless_not_found) > 1: md = MessageDialog(self) md.set_info_message("Metadata not found.") else: for file in self.dataless_not_found: md = MessageDialog(self) md.set_info_message("Metadata for {} not found.".format(file)) def validate_file(self): if not MseedUtil.is_valid_mseed(self.file_selector.file_path): msg = "The file {} is not a valid mseed. Please, choose a valid format". \ format(self.file_selector.file_name) raise InvalidFile(msg) def on_click_select_directory(self, bind: BindPyqtObject): if "darwin" == platform: dir_path = pw.QFileDialog.getExistingDirectory( self, 'Select Directory', bind.value) else: dir_path = pw.QFileDialog.getExistingDirectory( self, 'Select Directory', bind.value, pw.QFileDialog.DontUseNativeDialog) if dir_path: bind.value = dir_path def on_click_select_file(self, bind: BindPyqtObject): file_path = pw.QFileDialog.getOpenFileName(self, 'Select Directory', bind.value) file_path = file_path[0] if file_path: bind.value = file_path def on_click_select_metadata_file(self, bind: BindPyqtObject): selected = pw.QFileDialog.getOpenFileName(self, "Select metadata file") if isinstance(selected[0], str) and os.path.isfile(selected[0]): bind.value = selected[0] def onChange_metadata_path(self, value): md = MessageDialog(self) try: self.__metadata_manager = MetadataManager(value) self.inventory = self.__metadata_manager.get_inventory() print(self.inventory) md.set_info_message( "Loaded Metadata, please check your terminal for further details" ) except: md.set_error_message( "Something went wrong. Please check your metada file is a correct one" ) # def read_earth_model(self): # model = self.earth_model.getParametersWithFormat() # print(model) def plot_seismograms(self): parameters = self.get_inversion_parameters() lat = float(parameters['latitude']) lon = float(parameters['longitude']) starttime = convert_qdatetime_utcdatetime(self.starttime_date) endtime = convert_qdatetime_utcdatetime(self.endtime_date) diff = endtime - starttime parameters = self.parameters.getParameters() all_traces = [] obsfiles = MseedUtil.get_mseed_files(self.root_path_bind.value) obsfiles.sort() for file in obsfiles: sd = SeismogramDataAdvanced(file) if self.trimCB.isChecked() and diff >= 0: tr = sd.get_waveform_advanced( parameters, self.inventory, filter_error_callback=self.filter_error_message, start_time=starttime, end_time=endtime) else: tr = sd.get_waveform_advanced( parameters, self.inventory, filter_error_callback=self.filter_error_message) all_traces.append(tr) self.st = Stream(traces=all_traces) self.stream_frame = MatplotlibFrame(self.st, type='normal') self.stream_frame.show() if self.st: min_dist = self.min_distCB.value() max_dist = self.max_distCB.value() mt = MTIManager(self.st, self.inventory, lat, lon, min_dist, max_dist) [self.stream, self.deltas, self.stations_isola_path] = mt.get_stations_index() def stationsInfo(self): file_path = self.root_path_bind.value obsfiles = MseedUtil.get_mseed_files(self.root_path_bind.value) obsfiles.sort() sd = [] for file in obsfiles: st = SeismogramDataAdvanced(file) station = [ st.stats.Network, st.stats.Station, st.stats.Location, st.stats.Channel, st.stats.StartTime, st.stats.EndTime, st.stats.Sampling_rate, st.stats.Npts ] sd.append(station) self._stations_info = StationsInfo(sd, check=True) self._stations_info.show() def write(self): root_path = os.path.dirname(os.path.abspath(__file__)) if "darwin" == platform: dir_path = pw.QFileDialog.getExistingDirectory( self, 'Select Directory', root_path) else: dir_path = pw.QFileDialog.getExistingDirectory( self, 'Select Directory', root_path, pw.QFileDialog.DontUseNativeDialog) if not dir_path: return n = len(self.st) for j in range(n): tr = self.st[j] print(tr.id, "Writing data processed") path_output = os.path.join(dir_path, tr.id) tr.write(path_output, format="MSEED") ##In progress## def load_event_from_isolapath(self): root_path = os.path.dirname(os.path.abspath(__file__)) file_path = pw.QFileDialog.getOpenFileName(self, 'Select Directory', root_path) file = file_path[0] frame = pd.read_csv(file, sep='\s+', header=None) time = frame.iloc[3][0] year = time[0:4] mm = time[4:6] dd = time[6:8] hour = frame.iloc[4][0] minute = frame.iloc[5][0] sec = frame.iloc[6][0] sec = float(sec) dec = sec - int(sec) dec = int(sec) time = UTCDateTime(int(year), int(mm), int(dd), int(hour), int(minute), int(sec), dec) event = { 'lat': frame.iloc[0][0], 'lon': frame.iloc[0][1], 'depth': frame.iloc[1][0], 'mag': frame.iloc[2][0], 'time': time, 'istitution': frame.iloc[7][0] } return event @AsycTime.run_async() def run_inversion(self): parameters = self.get_inversion_parameters() try: stations_map = self._stations_info.get_stations_map() except: md = MessageDialog(self) md.set_info_message("Press Stations info and check your selection") if len(self.stream) and len(stations_map) > 0: isola = ISOLA(self.stream, self.deltas, location_unc=parameters['location_unc'], depth_unc=parameters['depth_unc'], time_unc=parameters['time_unc'], deviatoric=parameters['deviatoric'], threads=8, circle_shape=parameters['circle_shape'], use_precalculated_Green=parameters['GFs']) # isola.set_event_info(parameters['latitude'], parameters['longitude'], parameters['depth'], parameters['magnitude'], parameters['origin_time']) # print(isola.event) # # if self.stations_isola_path: isola.read_network_coordinates(self.stations_isola_path) isola.set_use_components(stations_map) #print(isola.stations) isola.read_crust(self.earth_path_bind.value) isola.set_parameters(parameters['freq_max'], parameters['freq_min']) self.infoTx.setPlainText("Calculated GFs") if not isola.calculate_or_verify_Green(): exit() self.infoTx.appendPlainText("Filtered and trim") isola.trim_filter_data() try: if parameters['covariance']: self.infoTx.appendPlainText( "Calculating Covariance Matrix") isola.covariance_matrix(crosscovariance=True, save_non_inverted=True, save_covariance_function=True) except: md = MessageDialog(self) md.set_error_message( "No Possible calculate covariance matrix, " "please try increasing the noise time window") # self.infoTx.appendPlainText("decimate and shift") isola.decimate_shift() self.infoTx.appendPlainText("Run inversion") isola.run_inversion() self.infoTx.appendPlainText("Finished Inversion") isola.find_best_grid_point() isola.print_solution() isola.print_fault_planes() self.infoTx.appendPlainText("Plotting Solutions") if len(isola.grid) > len(isola.depths): isola.plot_maps() self.infoTx.appendPlainText("plot_maps") if len(isola.depths) > 1: isola.plot_slices() self.infoTx.appendPlainText("plot_slices") if len(isola.grid) > len(isola.depths) and len( isola.depths) > 1: isola.plot_maps_sum() self.infoTx.appendPlainText("plot_maps_sum") try: isola.plot_MT() self.infoTx.appendPlainText("plot_MT") isola.plot_uncertainty(n=400) self.infoTx.appendPlainText("plot_uncertainty") #plot_MT_uncertainty_centroid() isola.plot_seismo('seismo.png') isola.plot_seismo('seismo_sharey.png', sharey=True) self.infoTx.appendPlainText("plot_seismo") if self.covarianceCB.isChecked(): isola.plot_seismo('plot_seismo.png', cholesky=True) self.infoTx.appendPlainText("plot_seismo_cova") isola.plot_noise() self.infoTx.appendPlainText("plot_noise") isola.plot_spectra() self.infoTx.appendPlainText("plot_spectra") isola.plot_stations() self.infoTx.appendPlainText("plot_stations") except: print("Couldn't Plot") try: if self.covarianceCB.isChecked(): isola.plot_covariance_matrix(colorbar=True) #isola.plot_3D() except: pass try: isola.html_log( h1='ISP Moment Tensor inversion', plot_MT='centroid.png', plot_uncertainty='uncertainty.png', plot_stations='stations.png', plot_seismo_cova='seismo_cova.png', plot_seismo_sharey='seismo_sharey.png', plot_spectra='spectra.png', plot_noise='noise.png', plot_covariance_matrix='covariance_matrix.png', plot_maps='map.png', plot_slices='slice.png', plot_maps_sum='map_sum.png') except: self.infoTx.appendPlainText("Couldn't load url") try: isola.html_log(h1='ISP Moment Tensor inversion', plot_MT='centroid.png', plot_uncertainty='uncertainty.png', plot_stations='stations.png', plot_seismo_sharey='seismo_sharey.png', plot_maps='map.png', plot_slices='slice.png') except: self.infoTx.appendPlainText("Couldn't load url") self.infoTx.appendPlainText( "Moment Tensor Inversion Successfully done !!!, please plot last solution" ) else: pass def plot_solution(self): path = os.path.join(ROOT_DIR, 'mti/output/index.html') url = pyc.QUrl.fromLocalFile(path) self.widget.load(url) def get_inversion_parameters(self): parameters = { 'latitude': self.latDB.value(), 'longitude': self.lonDB.value(), 'depth': self.depthDB.value(), 'origin_time': convert_qdatetime_utcdatetime(self.origin_time), 'location_unc': self.location_uncDB.value(), 'time_unc': self.timeDB.value(), 'magnitude': self.magnitudeDB.value(), 'depth_unc': self.depth_uncDB.value(), 'freq_min': self.freq_min_DB.value(), 'freq_max': self.freq_max_DB.value(), 'deviatoric': self.deviatoricCB.isChecked(), 'circle_shape': self.circle_shapeCB.isChecked(), 'GFs': self.gfCB.isChecked(), 'covariance': self.covarianceCB.isChecked() } return parameters def plot_map_stations(self): md = MessageDialog(self) md.hide() try: stations = [] obsfiles = MseedUtil.get_mseed_files(self.root_path_bind.value) obsfiles.sort() try: if len(self.stream) > 0: stations = ObspyUtil.get_stations_from_stream(self.stream) except: pass map_dict = {} sd = [] for file in obsfiles: if len(stations) == 0: st = SeismogramDataAdvanced(file) name = st.stats.Network + "." + st.stats.Station sd.append(name) st_coordinates = self.__metadata_manager.extract_coordinates( self.inventory, file) map_dict[name] = [ st_coordinates.Latitude, st_coordinates.Longitude ] else: st = SeismogramDataAdvanced(file) if st.stats.Station in stations: name = st.stats.Network + "." + st.stats.Station sd.append(name) st_coordinates = self.__metadata_manager.extract_coordinates( self.inventory, file) map_dict[name] = [ st_coordinates.Latitude, st_coordinates.Longitude ] else: pass self.map_stations = StationsMap(map_dict) self.map_stations.plot_stations_map(latitude=self.latDB.value(), longitude=self.lonDB.value()) md.set_info_message("Station Map OK !!! ") except: md.set_error_message( " Please check you have process and plot seismograms and opened stations info," "Please additionally check that your metada fits with your mseed files" ) md.show() def open_help(self): self.help.show()
class Controller: def __init__(self): self.main_frame = None self.time_frequency_frame = None self.earthquake_analysis_frame = None self.array_analysis_frame = None self.moment_tensor_frame = None self.receiver_functions_frame = None self.project_frame = None self.synthetics_frame = None self.data_download_frame = None self.ppds_frame = None self.realtime_frame = None self.noise_frame = None self.help = HelpDoc() def open_main_window(self): # Start the ui designer self.main_frame = MainFrame() # bind clicks self.main_frame.seismogramButton.clicked.connect( self.open_seismogram_window) self.main_frame.earthquakeButton.clicked.connect( self.open_earthquake_window) self.main_frame.arrayAnalysisButton.clicked.connect( self.open_array_window) self.main_frame.momentTensorButton.clicked.connect( self.open_momentTensor_window) self.main_frame.receiverFunctionsButton.clicked.connect( self.open_receiverFunctions) self.main_frame.noiseButton.clicked.connect(self.open_noise) self.main_frame.actionReal_Time.triggered.connect( self.open_realtime_window) self.main_frame.actionOpen_Project.triggered.connect(self.open_project) self.main_frame.actionCreate_new_Project.triggered.connect( self.create_project) self.main_frame.actionRetrieve_data.triggered.connect( self.retrieve_data) self.main_frame.actionPPSDs.triggered.connect(self.ppsds) self.main_frame.actionOpen_Help.triggered.connect( lambda: self.open_help()) # show frame self.main_frame.show() def open_seismogram_window(self): # Start the ui designer if not self.time_frequency_frame: self.time_frequency_frame = TimeFrequencyFrame() self.time_frequency_frame.show() def open_earthquake_window(self): # Start the ui designer if not self.earthquake_analysis_frame: self.earthquake_analysis_frame = EarthquakeAnalysisFrame() self.earthquake_analysis_frame.show() def open_realtime_window(self): # Start the ui designer if not self.realtime_frame: self.realtime_frame = RealTimeFrame() self.realtime_frame.show() def open_array_window(self): # Start the ui designer if not self.array_analysis_frame: self.array_analysis_frame = ArrayAnalysisFrame() self.array_analysis_frame.show() def open_momentTensor_window(self): # Start the ui designer if not self.moment_tensor_frame: self.moment_tensor_frame = MTIFrame() self.moment_tensor_frame.show() def open_receiverFunctions(self): if not self.receiver_functions_frame: self.receiver_functions_frame = RecfFrame() self.receiver_functions_frame.show() def open_noise(self): if not self.noise_frame: self.noise_frame = NoiseFrame() self.noise_frame.show() def open_project(self): if not self.project_frame: self.project_frame = EventLocationFrame() if not self.project_frame.isVisible(): self.project_frame.refreshLimits() self.project_frame.show() def create_project(self): if not self.synthetics_frame: self.synthetics_frame = SyntheticsAnalisysFrame() self.synthetics_frame.show() def retrieve_data(self): if not self.data_download_frame: self.data_download_frame = DataDownloadFrame() self.data_download_frame.show() def ppsds(self): if not self.ppds_frame: self.ppds_frame = PPSDFrame() self.ppds_frame.show() def open_help(self): self.help.show() def exception_parse(self, error_cls, exception, exc_traceback): md = MessageDialog(self.main_frame) detail_error = "".join( traceback.format_exception(error_cls, exception, exc_traceback)) md.set_error_message(message="{}:{}".format(error_cls.__name__, exception), detailed_message=detail_error) md.show()
class DataDownloadFrame(BaseFrame, UiDataDownloadFrame): def __init__(self): super(BaseFrame, self).__init__() self.setupUi(self) self.inventory = {} self.network_list = [] self.stations_list = [] self.catalogBtn.clicked.connect(self.get_catalog) self.event_dataBtn.clicked.connect(self.download_events) self.plotstationsBtn.clicked.connect(self.stations) self.TimeBtn.clicked.connect(self.download_time_series) self.MetadataBtn.clicked.connect(self.download_stations_xml) self.LoadBtn.clicked.connect(self.load_inventory) # Map self.cartopy_canvas = CartopyCanvas(self.map) self.cartopy_canvas.global_map(0) self.cartopy_canvas.figure.subplots_adjust(left=0.00, bottom=0.055, right=0.97, top=0.920, wspace=0.0, hspace=0.0) self.activated_colorbar = True self.cartopy_canvas.on_double_click(self.on_click_matplotlib) self.cartopy_canvas.mpl_connect('key_press_event', self.key_pressed) self.cartopy_canvas.mpl_connect('button_press_event', self.press_right) self.actionOpen_Help.triggered.connect(lambda: self.open_help()) # signal doubleclick self.tableWidget.cellDoubleClicked.connect(self.get_coordinates) # help Documentation self.help = HelpDoc() # self.latitudes = [] self.longitudes = [] self.depths = [] self.magnitudes = [] def get_coordinates(self, row, column): lat = self.tableWidget.item(row, 1).data(0) lon = self.tableWidget.item(row, 2).data(0) lat30, lon30, lat90, lon90 = retrieve.get_circle(lat, lon) self.cartopy_canvas.global_map(0, clear_plot=False, show_distance_circles=True, lon30=lon30, lat30=lat30, lon90=lon90, lat90=lat90) #ax = self.cartopy_canvas.get_axe(0) #self.line1 = ax.scatter(lon30, lat30, s=8, c="white") #self.line2 = ax.scatter(lon90, lat90, s=8, c="white") def get_catalog(self): latitudes = [] longitudes = [] depths = [] magnitudes = [] starttime = convert_qdatetime_utcdatetime(self.start_dateTimeEdit) endtime = convert_qdatetime_utcdatetime(self.end_dateTimeEdit) minmagnitude = self.min_magnitudeCB.value() maxmagnitude = self.max_magnitudeCB.value() mindepth = self.depth_minCB.value() maxdepth = self.depth_maxCB.value() try: md = MessageDialog(self) md.hide() catalog = self.client.get_events(starttime=starttime, endtime=endtime, mindepth=mindepth, maxdepth=maxdepth, minmagnitude=minmagnitude, maxmagnitude=maxmagnitude) for event in catalog: otime = event.origins[0].time lat = event.origins[0].latitude lon = event.origins[0].longitude depth = event.origins[0].depth magnitude = event.magnitudes[0].mag magnitude_type = event.magnitudes[0].magnitude_type # append results latitudes.append(lat) longitudes.append(lon) depths.append(depth) magnitudes.append(magnitude) self.tableWidget.insertRow(self.tableWidget.rowCount()) self.tableWidget.setItem( self.tableWidget.rowCount() - 1, 0, QtWidgets.QTableWidgetItem(str(otime))) self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 1, QtWidgets.QTableWidgetItem(str(lat))) self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 2, QtWidgets.QTableWidgetItem(str(lon))) try: self.tableWidget.setItem( self.tableWidget.rowCount() - 1, 3, QtWidgets.QTableWidgetItem(str(depth / 1000))) except TypeError: self.tableWidget.setItem(self.tableWidget.rowCount() - 1, 3, QtWidgets.QTableWidgetItem("N/A")) self.tableWidget.setItem( self.tableWidget.rowCount() - 1, 4, QtWidgets.QTableWidgetItem(str(magnitude))) self.tableWidget.setItem( self.tableWidget.rowCount() - 1, 5, QtWidgets.QTableWidgetItem(str(magnitude_type))) selection_range = QtWidgets.QTableWidgetSelectionRange( 0, 0, self.tableWidget.rowCount() - 1, self.tableWidget.columnCount() - 1) #print(selection_range.bottomRow()) self.longitudes = longitudes self.latitudes = latitudes self.depths = depths self.magnitudes = magnitudes self.tableWidget.setRangeSelected(selection_range, True) #print(selection_range) self.catalog_out = [latitudes, longitudes, depths, magnitudes] # plot earthquakes self.cartopy_canvas.global_map( 0, plot_earthquakes=True, show_colorbar=self.activated_colorbar, lat=latitudes, lon=longitudes, depth=depths, magnitude=magnitudes, resolution=self.typeCB.currentText()) self.activated_colorbar = False self.event_dataBtn.setEnabled(True) md.set_info_message("Catalog generated succesfully!!!") md.show() except: md.set_error_message( "Something wet wrong, Please check that you have: 1- Loaded Inventory, " "2- Search Parameters have sense") md.show() #obspy.clients.fdsn.client.Client def download_events(self): root_path = os.path.dirname(os.path.abspath(__file__)) if "darwin" == platform: dir_path = pw.QFileDialog.getExistingDirectory( self, 'Select Directory', root_path) else: dir_path = pw.QFileDialog.getExistingDirectory( self, 'Select Directory', root_path, pw.QFileDialog.DontUseNativeDialog) if not dir_path: return starttime = convert_qdatetime_utcdatetime(self.start_dateTimeEdit) endtime = convert_qdatetime_utcdatetime(self.end_dateTimeEdit) selected_items = self.tableWidget.selectedItems() event_dict = {} errors = False row = 0 column = 0 for i, item in enumerate(selected_items): event_dict.setdefault(row, {}) header = self.tableWidget.horizontalHeaderItem(column).text() event_dict[row][header] = item.text() column += 1 if i % 5 == 0 and i > 0: row += 1 column = 0 # Get stations networks = self.networksLE.text() stations = self.stationsLE.text() channels = self.channelsLE.text() if self.Earthworm_CB.isChecked(): ip_address = self.IP_LE.text() port = self.portLE.text() client_earthworm = obspy.clients.earthworm.Client( ip_address, int(port)) inventory = client_earthworm.get_stations(network=networks, station=stations, starttime=starttime, endtime=endtime) else: inventory = self.client.get_stations(network=networks, station=stations, starttime=starttime, endtime=endtime) model = obspy.taup.TauPyModel(model="iasp91") for event in event_dict.keys(): otime = obspy.UTCDateTime(event_dict[event]['otime']) evla = float(event_dict[event]['lat']) evlo = float(event_dict[event]['lon']) evdp = float(event_dict[event]['depth']) for ntwk in inventory: ntwknm = ntwk.code for stn in ntwk: stnm = stn.code stla = stn.latitude stlo = stn.longitude #stev = stn.elevation # Distance, azimuth and back_azimuth for event: m_dist, az, back_az = obspy.geodetics.base.gps2dist_azimuth( evla, evlo, stla, stlo) deg_dist = obspy.geodetics.base.kilometers2degrees(m_dist / 1000) atime = model.get_travel_times(source_depth_in_km=evdp, distance_in_degree=deg_dist, receiver_depth_in_km=0.0) p_onset = otime + atime[0].time start = p_onset - self.timebeforeCB.value() end = p_onset + self.timeafterCB.value() try: st = self.client.get_waveforms(ntwknm, stnm, "*", channels, start, end) print(st) self.write(st, dir_path) except: errors = True md = MessageDialog(self) md.set_error_message(ntwknm + "." + stnm + "." + channels + " " + "Couldn't download data") if errors: md = MessageDialog(self) md.set_info_message("Download completed with some errors") else: md = MessageDialog(self) md.set_info_message("Download completed") def download_stations_xml(self): fname = QtWidgets.QFileDialog.getSaveFileName()[0] starttime = convert_qdatetime_utcdatetime(self.start_dateTimeEdit) endtime = convert_qdatetime_utcdatetime(self.end_dateTimeEdit) networks = self.networksLE.text() stations = self.stationsLE.text() channels = self.channelsLE.text() inventory = self.client.get_stations(network=networks, station=stations, starttime=starttime, endtime=endtime, level="response") try: print("Getting metadata from ", networks, stations, channels, starttime, endtime) inventory.write(fname, format="STATIONXML") md = MessageDialog(self) md.set_info_message("Download completed") except: md = MessageDialog(self) md.set_error_message("Metadata coudn't be downloaded") def download_time_series(self): starttime = convert_qdatetime_utcdatetime(self.start_dateTimeEdit) endtime = convert_qdatetime_utcdatetime(self.end_dateTimeEdit) networks = self.networksLE.text() stations = self.stationsLE.text() channels = self.channelsLE.text() try: print("Getting data from ", networks, stations, channels, starttime, endtime) st = self.client.get_waveforms(networks, stations, "*", channels, starttime, endtime) if len(st) > 0: root_path = os.path.dirname(os.path.abspath(__file__)) if "darwin" == platform: dir_path = pw.QFileDialog.getExistingDirectory( self, 'Select Directory', root_path) else: dir_path = pw.QFileDialog.getExistingDirectory( self, 'Select Directory', root_path, pw.QFileDialog.DontUseNativeDialog) self.write(st, dir_path) except: md = MessageDialog(self) md.set_info_message("Couldn't download time series") def write(self, st, dir_path): if dir_path: n = len(st) try: for j in range(n): tr = st[j] t1 = tr.stats.starttime id = tr.id + "." + "D" + "." + str(t1.year) + "." + str( t1.julday) print(tr.id, "Writing data processed") path_output = os.path.join(dir_path, id) tr.write(path_output, format="MSEED") except: md = MessageDialog(self) md.set_info_message("Nothing to write") def load_inventory(self): #self.networksLE.setText("") self.stationsLE.setText("") self.channelsLE.setText("") starttime = convert_qdatetime_utcdatetime(self.start_dateTimeEdit) endtime = convert_qdatetime_utcdatetime(self.end_dateTimeEdit) self.retrivetool = retrieve() try: self.inventory, self.client = self.retrivetool.get_inventory( self.URL_CB.currentText(), starttime, endtime, self.networksLE.text(), self.stationsLE.text(), use_networks=self.netsCB.isChecked(), FDSN=self.FDSN_CB.isChecked(), ip_address=self.IP_LE.text(), port=self.portLE.text()) if self.inventory and self.client is not None: md = MessageDialog(self) md.set_info_message("Loaded Inventory from Address") self.plotstationsBtn.setEnabled(True) self.catalogBtn.setEnabled(True) else: md = MessageDialog(self) md.set_info_message( "The current client does not have a station service. " "Please check that you do not have selected -just specific nets- and the net " "field provide a net name that is not expected in this service" ) except: md = MessageDialog(self) md.set_info_message( "The current client does not have a station service") def stations(self): coordinates = self.retrivetool.get_inventory_coordinates( self.inventory) self.cartopy_canvas.global_map( 0, plot_earthquakes=False, show_colorbar=False, show_stations=True, show_station_names=self.namesCB.isChecked(), clear_plot=True, coordinates=coordinates, resolution=self.typeCB.currentText()) if len(self.latitudes) > 0 and len(self.longitudes) and len( self.depths) and len(self.magnitudes) > 0: self.cartopy_canvas.global_map( 0, plot_earthquakes=True, show_colorbar=self.activated_colorbar, clear_plot=False, lat=self.latitudes, lon=self.longitudes, depth=self.depths, magnitude=self.magnitudes, resolution=self.typeCB.currentText()) def on_click_matplotlib(self, event, canvas): self.retrivetool = retrieve() if isinstance(canvas, CartopyCanvas): x1, y1 = event.xdata, event.ydata data = self.retrivetool.get_station_id(x1, y1, self.inventory) if len(data[0]) > 0 and len(data[1]) > 0: if data[0] not in self.network_list: self.network_list.append(data[0]) self.networksLE.setText(",".join(self.network_list)) if data[1] not in self.stations_list: self.stations_list.append(data[1]) self.stationsLE.setText(",".join(self.stations_list)) def key_pressed(self, event): self.network_list = [] self.stations_list = [] if event.key == 'c': self.networksLE.setText(",".join(self.network_list)) self.stationsLE.setText(",".join(self.stations_list)) def press_right(self, event): self.retrivetool = retrieve() if event.dblclick: if event.button == 3: x1, y1 = event.xdata, event.ydata data = self.retrivetool.get_station_id(x1, y1, self.inventory) if len(data[0]) > 0 and len(data[1]) > 0: if data[0] in self.network_list: self.network_list.remove(data[0]) self.networksLE.setText(",".join(self.network_list)) if data[1] in self.stations_list: self.stations_list.remove(data[1]) self.stationsLE.setText(",".join(self.stations_list)) def open_help(self): self.help.show()