def make_xasplot_func(self, plan_name, plan_kwargs): detectors = plan_kwargs['detectors'] if plan_name in ['step_scan_plan', 'step_scan_von_hamos_plan', 'step_scan_johann_herfd_plan']: motor_name = self.hhm.energy.name elif plan_name in ['step_scan_johann_xes_plan']: motor_name = self.johann_spectrometer_motor.energy.name elif plan_name in ['fly_scan_plan', 'fly_scan_von_hamos_plan', 'fly_scan_johann_herfd_plan']: return [] else: motor_name = 'time' update_figure([self.figure.ax2, self.figure.ax1, self.figure.ax3], self.toolbar, self.canvas) xasplot_list = [] liveplot_kwargs_list = [{'num_name': 'apb_ave_ch1_mean', 'den_name': 'apb_ave_ch2_mean', 'result_name': 'Transmission', 'log': True, 'ax': self.figure.ax1, 'color': 'r', 'legend_keys': ['Transmission']}, {'num_name': 'apb_ave_ch2_mean', 'den_name': 'apb_ave_ch3_mean', 'result_name': 'Reference', 'log': True, 'ax': self.figure.ax2, 'color': 'b', 'legend_keys': ['Reference']}, {'num_name': 'apb_ave_ch4_mean', 'den_name': 'apb_ave_ch1_mean', 'result_name': 'PIPS TFY', 'log': False, 'ax': self.figure.ax3, 'color': 'g', 'legend_keys': ['PIPS TFY']}, ] if 'Pilatus 100k' in detectors: liveplot_kwargs_list.append( {'num_name': 'pil100k_stats1_total', 'den_name': 'apb_ave_ch1_mean', 'result_name': 'HERFD', 'log': False, 'ax': self.figure.ax3, 'color': 'm', 'legend_keys': ['HERFD']}) if 'Xspress3' in detectors: liveplot_kwargs_list.append( {'num_name': 'xs_channel1_rois_roi01_value', 'den_name': 'apb_ave_ch2_mean', 'result_name': 'SDD', 'log': False, 'ax': self.figure.ax3, 'color': 'm', 'legend_keys': ['SDD']}) for liveplot_kwargs in liveplot_kwargs_list: _xasplot = self._xasplot_from_dict(liveplot_kwargs, motor_name) xasplot_list.append(_xasplot) return xasplot_list
def run_gen_scan(self): if not self.shutters_open: return detectors, liveplot_det_kwargs = self._get_detectors_for_gen_scan() motor, liveplot_mot_kwargs = self._get_motor_for_gen_scan() rel_start = -float(self.edit_gen_range.text()) / 2 rel_stop = float(self.edit_gen_range.text()) / 2 num_steps = int( round( float(self.edit_gen_range.text()) / float(self.edit_gen_step.text()))) + 1 update_figure([self.figure_gen_scan.ax], self.toolbar_gen_scan, self.canvas_gen_scan) plan_name = 'general_scan' plan_kwargs = { 'detectors': detectors, 'motor': motor, 'rel_start': rel_start, 'rel_stop': rel_stop, 'num_steps': num_steps, 'liveplot_kwargs': { **liveplot_det_kwargs, **liveplot_mot_kwargs } } self.plan_processor.add_plan_and_run_if_idle(plan_name, plan_kwargs)
def plot_project_in_K(self): if self.list_project.selectedIndexes(): update_figure([self.figure_project.ax], self.toolbar_project, self.canvas_project) window = self.set_ft_window() for index in self.list_project.selectedIndexes(): ds = self.parent.project[index.row()] ds.extract_chi_force() ds.extract_ft_force(window=window) data = ds.chi * np.power(ds.k, self.spinBox_k_weight.value()) self.figure_project.ax.plot(ds.k, data, label=ds.name) data_max = data.max() if self.checkBox_show_window.isChecked(): self.figure_project.ax.plot(ds.k, ds.kwin * data_max / 2, label='Windows') self.parent.set_figure(self.figure_project.ax, self.canvas_project, label_x='k (' + r'$\AA$' + '$^1$' + ')', label_y=r'$\chi \mu$' + '(k)') if self.checkBox_force_range_k.checkState(): self.figure_project.ax.set_xlim( float(self.lineEdit_range_k_lo.text()), float(self.lineEdit_range_k_hi.text())) self.current_plot_in = 'k'
def plot_project_in_R(self): if self.list_project.selectedIndexes(): update_figure([self.figure_project.ax], self.toolbar_project, self.canvas_project) window = self.set_ft_window() for index in self.list_project.selectedIndexes(): ds = self.parent.project[index.row()] ds.extract_ft_force(window=window) if self.checkBox_show_chir_mag.checkState(): self.figure_project.ax.plot(ds.r, ds.chir_mag, label=ds.name) if self.checkBox_show_chir_im.checkState(): self.figure_project.ax.plot(ds.r, ds.chir_im, label=(ds.name + ' Im')) if self.checkBox_show_chir_re.checkState(): self.figure_project.ax.plot(ds.r, ds.chir_re, label=(ds.name + ' Re')) # if self.checkBox_show_chir_pha.checked: # self.figure_project.ax.plot(ds.r, ds.chir_pha, label=(ds.name + ' Ph')) self.parent.set_figure(self.figure_project.ax, self.canvas_project, label_y=r'$\chi \mu$' + '(k)', label_x='R (' + r'$\AA$' + ')') if self.checkBox_force_range_R.checkState(): self.figure_project.ax.set_xlim( float(self.lineEdit_range_R_lo.text()), float(self.lineEdit_range_R_hi.text())) self.current_plot_in = 'R'
def draw_interpolated_data(self, df): update_figure([self.figure.ax2, self.figure.ax1, self.figure.ax3], self.toolbar, self.canvas) if 'i0' in df and 'it' in df and 'energy' in df: transmission = np.array(np.log(df['i0'] / df['it'])) if 'i0' in df and 'pips' in df and 'energy' in df: fluorescence = np.array(df['pips'] / df['i0']) if 'it' in df and 'ir' in df and 'energy' in df: reference = np.array(np.log(df['it'] / df['ir'])) energy = np.array(df['energy']) edge = int(len(energy) * 0.02) self.figure.ax1.plot(energy[edge:-edge], transmission[edge:-edge], color='r', label='Transmission') self.figure.ax1.legend(loc=2) self.figure.ax2.plot(energy[edge:-edge], fluorescence[edge:-edge], color='g', label='Total fluorescence') self.figure.ax2.legend(loc=1) self.figure.ax3.plot(energy[edge:-edge], reference[edge:-edge], color='b', label='Reference') self.figure.ax3.legend(loc=3) self.canvas.draw_idle()
def plot_project_in_E(self): if self.list_project.selectedIndexes(): update_figure([self.figure_project.ax], self.toolbar_project, self.canvas_project) for index in self.list_project.selectedIndexes(): ds = self.parent.project[index.row()] self._normalize_ds_in_full(ds) # ds.normalize_force() # ds.extract_chi_force() # ds.extract_ft_force() # ds.extract_ft() ds.extract_ft_force() energy = ds.energy if self.radioButton_mu_xasproject.isChecked(): data = ds.mu elif self.radioButton_norm_xasproject.isChecked(): if self.checkBox_norm_flat_xasproject.checkState(): data = ds.flat else: data = ds.norm if self.checkBox_deriv.isChecked(): if not hasattr(ds, 'mu_deriv'): ds.deriv() data = ds.mu_deriv energy = ds.energy_deriv self.figure_project.ax.plot(energy, data, label=ds.name) if self.radioButton_mu_xasproject.isChecked( ) and not self.checkBox_deriv.isChecked(): if self.checkBox_preedge_show.checkState(): self.figure_project.ax.plot(ds.energy, ds.pre_edge, label='Preedge', linewidth=0.75) if self.checkBox_postedge_show.checkState(): self.figure_project.ax.plot(ds.energy, ds.post_edge, label='Postedge', linewidth=0.75) if self.checkBox_background_show.checkState(): self.figure_project.ax.plot(ds.energy, ds.bkg, label='Background', linewidth=0.75) self.parent.set_figure(self.figure_project.ax, self.canvas_project, label_x='Energy /eV', label_y=r'$\chi \mu$' + '(E)'), if self.checkBox_force_range_E.checkState(): self.figure_project.ax.set_xlim( (float(self.lineEdit_e0.text()) + float(self.lineEdit_range_E_lo.text())), (float(self.lineEdit_e0.text()) + float(self.lineEdit_range_E_hi.text()))) self.current_plot_in = 'e'
def parse_rixs_scan(self): selected_items = (self.list_data.selectedItems()) update_figure([self.figure_rixs.ax], self.toolbar, self.canvas) path = f'{self.working_folder}/{selected_items[0].text()}' self.rixs_dict = parse_rixslog_scan(self.db, path) self.process_rixs_dict() self.doubleSpinBox_contourf_vmin.setValue(self._plot_data.min()) self.doubleSpinBox_contourf_vmax.setValue(np.median(self._plot_data))
def update_plotting_status(self): now = ttime.time() timewindow = self.doubleSpinBox_timewindow.value() data_format = mdates.DateFormatter('%H:%M:%S') some_time_ago = now - 3600 * timewindow df = self.archiver.tables_given_times(some_time_ago, now) self._df_ = df self._xlim_num = [some_time_ago, now] # handling the xlim extension due to the program vizualization if self.plot_program_flag: if self._plot_program_data is not None: self._xlim_num[1] = np.max([self._plot_program_data['time_s'].iloc[-1], self._xlim_num[1]]) _xlim = [ttime.ctime(self._xlim_num[0]), ttime.ctime(self._xlim_num[1])] masses = [] for rga_mass in self.rga_masses: masses.append(str(rga_mass.get())) update_figure([self.figure_rga.ax], self.toolbar_rga, self.canvas_rga) for rga_ch, mass in zip(self.rga_channels, masses): dataset = df[rga_ch.name] indx = rga_ch.name[-1] if getattr(self, f'checkBox_rga{indx}').isChecked(): # put -5 in the winter, -4 in the summer self.figure_rga.ax.plot(dataset['time'] + timedelta(hours=-4), dataset['data'], label=f'{mass} amu') self.figure_rga.ax.grid(alpha=0.4) self.figure_rga.ax.xaxis.set_major_formatter(data_format) self.figure_rga.ax.set_xlim(_xlim) self.figure_rga.ax.autoscale_view(tight=True) self.figure_rga.ax.set_yscale('log') self.figure_rga.tight_layout() self.figure_rga.ax.legend(loc=6) self.canvas_rga.draw_idle() update_figure([self.figure_temp.ax], self.toolbar_temp, self.canvas_temp) dataset_rb = df['temp2'] dataset_sp = df['temp2_sp'] dataset_sp = self._pad_dataset_sp(dataset_sp, dataset_rb['time'].values[-1]) self.figure_temp.ax.plot(dataset_sp['time'] + timedelta(hours=-4), dataset_sp['data'], label='T setpoint') self.figure_temp.ax.plot(dataset_rb['time'] + timedelta(hours=-4), dataset_rb['data'], label='T readback') self.plot_pid_program() self.figure_temp.ax.grid(alpha=0.4) self.figure_temp.ax.xaxis.set_major_formatter(data_format) self.figure_temp.ax.set_xlim(_xlim) self.figure_temp.ax.set_ylim(self.spinBox_temp_range_min.value(), self.spinBox_temp_range_max.value()) self.figure_temp.ax.autoscale_view(tight=True) self.figure_temp.tight_layout() self.figure_temp.ax.legend(loc=6) self.canvas_temp.draw_idle()
def plot_trajectory_func(self, x, y): update_figure([self.figure_trajectory.ax1,self.figure_trajectory.ax2 ], self.toolbar_trajectory, self.canvas_trajectory) self.figure_trajectory.ax1.plot(x, y) self.figure_trajectory.ax1.set_xlabel('Time, s') self.figure_trajectory.ax1.set_ylabel('Energy, eV') self.figure_trajectory.ax2.plot(x[:-1], np.diff(y) / np.diff(x), 'r--') self.figure_trajectory.ax2.set_ylabel('Velocity (eV/s)') self.figure_trajectory.ax1.set_xlim(x.min(), x.max()) self.figure_trajectory.ax2.set_xlim(x.min(), x.max()) self.canvas_trajectory.draw_idle()
def plot_xas_data(self): selected_items = (self.list_data.selectedItems()) update_figure([self.figure_data.ax], self.toolbar, self.canvas) if self.comboBox_data_numerator.currentText( ) == -1 or self.comboBox_data_denominator.currentText() == -1: message_box('Warning', 'Please select numerator and denominator') return self.last_numerator = self.comboBox_data_numerator.currentText() self.last_denominator = self.comboBox_data_denominator.currentText() energy_key = 'energy' handles = [] for i in selected_items: path = f'{self.working_folder}/{i.text()}' print(path) df, header = load_binned_df_from_file(path) numer = np.array(df[self.comboBox_data_numerator.currentText()]) denom = np.array(df[self.comboBox_data_denominator.currentText()]) if self.checkBox_ratio.checkState(): y_label = (f'{self.comboBox_data_numerator.currentText()} / ' f'{self.comboBox_data_denominator.currentText()}') spectrum = numer / denom else: y_label = (f'{self.comboBox_data_numerator.currentText()}') spectrum = numer if self.checkBox_log_bin.checkState(): spectrum = np.log(spectrum) y_label = f'ln ({y_label})' if self.checkBox_inv_bin.checkState(): spectrum = -spectrum y_label = f'- {y_label}' self.figure_data.ax.plot(df[energy_key], spectrum) self.parent.set_figure(self.figure_data.ax, self.canvas, label_x='Energy (eV)', label_y=y_label) self.figure_data.ax.set_xlabel('Energy (eV)') self.figure_data.ax.set_ylabel(y_label) last_trace = self.figure_data.ax.get_lines()[ len(self.figure_data.ax.get_lines()) - 1] patch = mpatches.Patch(color=last_trace.get_color(), label=i.text()) handles.append(patch) self.figure_data.ax.legend(handles=handles) self.figure_data.tight_layout() self.canvas.draw_idle()
def plot_traces(self): #THis method plot the MCA signal update_figure([self.figure_mca.ax], self.toolbar_mca, self.canvas_mca) self.roi_plots = [] if self.acquired: for indx in range(self.num_channels): if getattr(self, self.checkbox_ch.format(indx+1)).isChecked(): ch = getattr(self.xs,'mca{}'.format(indx+1)) mca = ch.get() # energy = np.array(list(range(len(mca))))*10 energy = np.arange(mca.size)*10 self.figure_mca.ax.plot(energy[10:], mca[10:], self.colors[indx], label = 'Channel {}'.format(indx+1)) self.figure_mca.ax.legend(loc=1) self.update_roi_plot()
def plot_binned_datasets(self): update_figure([self.figure_binned_scans.ax], self.toolbar_binned_scans, self.canvas_binned_scans) for dataset in self.binned_datasets: if self.checkBox_ratio.isChecked(): result = dataset[self.last_num_text] / dataset[ self.last_den_text] ylabel = f'{self.last_num_text} / {self.last_den_text}' else: result = dataset[self.last_num_text] ylabel = f'{self.last_num_text}' if self.checkBox_log.checkState(): result = np.log(result) if self.checkBox_neg.checkState(): result = -result self.figure_binned_scans.ax.plot(dataset['energy'], result) self.figure_binned_scans.ax.set_ylabel(ylabel) self.figure_binned_scans.ax.set_xlabel('Energy /eV') self.figure_binned_scans.tight_layout() self.canvas_binned_scans.draw_idle() self.push_replot_file.setEnabled(True)
def update_proc_figure(self, x_key): # managing figures self.canvas_proc.mpl_disconnect(self.cid_proc) if x_key == 'calibration': update_figure([self.figure_proc.ax], self.toolbar_proc, self.canvas_proc) data = self.widget_johann_tools._calibration_data energy_nom = data['energy_nom'].values energy_act = data['energy_act'].values energy_error = energy_act - energy_nom resolution = data['resolution'].values ax = self.figure_proc.ax ax.plot(energy_nom, energy_error, 'k.-') ax.set_xlabel('nominal energy, eV') ax.set_ylabel('energy error, eV') ax2 = self.figure_proc.ax.twinx() ax2.plot(energy_nom, resolution, 'rs-') ax2.set_ylabel('resolution, eV', color='r') ax.set_xlim(energy_nom.min() - 10, energy_nom.max() + 10) else: motor_pos = self.widget_johann_tools._alignment_data[x_key].values fwhm = self.widget_johann_tools._alignment_data['fwhm'].values ecen = self.widget_johann_tools._alignment_data['ecen'].values res = np.sqrt(fwhm**2 - (1.3e-4 * ecen)**2) for each_pos, each_fwhm, each_res in zip(motor_pos, fwhm, res): self.figure_proc.ax.plot(each_pos, each_fwhm, 'o') self.figure_proc.ax.plot(each_pos, each_res, '+') self.figure_proc.ax.set_ylabel('FWHM/resolution, eV') self.figure_proc.ax.set_xlabel(x_key) self.figure_proc.tight_layout() self.canvas_proc.draw_idle() self.cid_proc = self.canvas_proc.mpl_connect('button_press_event', self.getX_proc)
def run_time_scan(self): self.canvas_scan.mpl_disconnect(self.cid_scan) update_figure([self.figure_scan.ax], self.toolbar_scan, self.canvas_scan) self.figure_scan.ax.set_aspect('auto') nframes = int(self.doubleSpinBox_nframes.value()) lp = XASPlot('pil100k_stats1_total', 'apb_ave_ch1_mean', 'normalized I', 'time', log=False, ax=self.figure_scan.ax, color='k', legend_keys=['I']) plan = self.service_plan_funcs['n_pil100k_exposures_plan'](nframes) self.RE(plan, lp) self.figure_scan.tight_layout() self.canvas_scan.draw_idle() self.cid_scan = self.canvas_scan.mpl_connect('button_press_event', self.getX_scan) self.last_motor_used = None
def build_trajectory(self): E0 = float(self.e0) preedge_lo = int(self.edit_preedge_lo.text()) preedge_hi = int(self.edit_preedge_hi.text()) edge_hi = int(self.edit_edge_hi.text()) postedge_k = float(self.edit_postedge_hi.text()) postedge_hi = xray.k2e( postedge_k, E0 ) - E0 # (1000 * ((postedge_k ** 2) + (16.2009 ** 2) * E0/1000) / (16.2009 ** 2)) - E0 velocity_preedge = int(self.edit_velocity_preedge.text()) velocity_edge = int(self.edit_velocity_edge.text()) velocity_postedge = int(self.edit_velocity_postedge.text()) preedge_stitch_lo = int(self.edit_preedge_stitch_lo.text()) preedge_stitch_hi = int(self.edit_preedge_stitch_hi.text()) edge_stitch_lo = int(self.edit_edge_stitch_lo.text()) edge_stitch_hi = int(self.edit_edge_stitch_hi.text()) postedge_stitch_lo = int(self.edit_postedge_stitch_lo.text()) postedge_stitch_hi = int(self.edit_postedge_stitch_hi.text()) padding_preedge = float(self.edit_padding_preedge.text()) padding_postedge = float(self.edit_padding_postedge.text()) sine_duration = float(self.edit_sine_total_duration.text()) traj_type = self.tabWidget_2.tabText(self.tabWidget_2.currentIndex()) if traj_type == 'Double Sine': dsine_preedge_duration = float(self.edit_ds_pree_duration.text()) dsine_postedge_duration = float(self.edit_ds_poste_duration.text()) else: dsine_preedge_duration = float(self.edit_ds2_pree_duration.text()) dsine_postedge_duration = float( self.edit_ds2_poste_duration.text()) vel_edge = float(self.edit_vel_edge.text()) #Define element and edge self.traj_creator.elem = f'{self.element}' self.traj_creator.edge = f'{self.edge}' self.traj_creator.e0 = f'{self.e0}' # Create and interpolate trajectory self.traj_creator.define(edge_energy=E0, offsets=([preedge_lo, preedge_hi, edge_hi, postedge_hi]), velocities=([velocity_preedge, velocity_edge, velocity_postedge]), \ stitching=([preedge_stitch_lo, preedge_stitch_hi, edge_stitch_lo, edge_stitch_hi, postedge_stitch_lo, postedge_stitch_hi]), \ servocycle=16000, padding_lo=padding_preedge, padding_hi=padding_postedge, sine_duration=sine_duration, dsine_preedge_duration=dsine_preedge_duration, dsine_postedge_duration=dsine_postedge_duration, trajectory_type=traj_type, vel_edge=vel_edge) self.traj_creator.interpolate() # Revert trajectory if checkbox checked if self.checkBox_traj_revert.isChecked( ) and self.checkBox_traj_revert.isEnabled(): self.traj_creator.revert() # Plot single trajectory motion update_figure([ self.figure_single_trajectory.ax, self.figure_single_trajectory.ax2 ], self.toolbar_single_trajectory, self.canvas_single_trajectory) self.figure_single_trajectory.ax.plot(self.traj_creator.time, self.traj_creator.energy, 'ro') self.figure_single_trajectory.ax.plot(self.traj_creator.time_grid, self.traj_creator.energy_grid, 'b') self.figure_single_trajectory.ax.set_xlabel('Time (s)') self.figure_single_trajectory.ax.set_ylabel('Energy (eV)') self.figure_single_trajectory.ax2.plot( self.traj_creator.time_grid[0:-1], self.traj_creator.energy_grid_der, 'r') self.figure_single_trajectory.ax2.set_ylabel('Velocity (eV/s)') self.canvas_single_trajectory.draw_idle() # Tile trajectory update_figure([self.figure_full_trajectory.ax], self.toolbar_full_trajectory, self.canvas_full_trajectory) self.traj_creator.tile( reps=self.spinBox_tiling_repetitions.value(), single_direction=self.checkBox_traj_single_dir.isChecked()) # Convert to encoder counts self.traj_creator.e2encoder(float(self.label_angle_offset.text())) # Draw self.figure_full_trajectory.ax.plot(self.traj_creator.encoder_grid, 'b') self.figure_full_trajectory.ax.set_xlabel('Servo event / 1/16000 s') self.figure_full_trajectory.ax.set_ylabel('Encoder count') self.canvas_full_trajectory.draw_idle() self.push_save_trajectory.setEnabled(True)
def run_scan(self): ignore_shutter = False energy_grid = [] time_grid = [] for shutter in [ self.shutter_dictionary[shutter] for shutter in self.shutter_dictionary if self.shutter_dictionary[shutter].shutter_type != 'SP' ]: if shutter.state.value: ret = question_message_box( self, 'Shutter closed', 'Would you like to run the scan with the shutter closed?') if not ret: print('Aborted!') return False ignore_shutter = True break # Send sampling time to the pizzaboxes: value = int( round( float(self.analog_samp_time) / self.adc_list[0].sample_rate.get() * 100000)) for adc in self.adc_list: adc.averaging_points.put(str(value)) for enc in self.enc_list: enc.filter_dt.put(float(self.enc_samp_time) * 100000) # not needed at QAS this is a detector if self.xia is not None: if self.xia.input_trigger is not None: self.xia.input_trigger.unit_sel.put(1) # ms, not us self.xia.input_trigger.period_sp.put(int(self.xia_samp_time)) name_provided = self.parameter_values[0].text() if name_provided: timenow = datetime.datetime.now() print('\nStarting scan at {}'.format(timenow.strftime("%H:%M:%S"), flush='true')) start_scan_timer = timer() # Get parameters from the widgets and organize them in a dictionary (run_params) run_parameters = return_parameters_from_widget( self.parameter_descriptions, self.parameter_values, self.parameter_types) # Run the scan using the dict created before self.run_mode_uids = [] self.parent_gui.run_mode = 'run' plan_key = self.comboBox_scan_type.currentText() if plan_key == 'Step scan': update_figure( [self.figure.ax2, self.figure.ax1, self.figure.ax3], self.toolbar, self.canvas) energy_grid, time_grid = generate_energy_grid( float(self.e0), float(self.edit_preedge_start.text()), float(self.edit_xanes_start.text()), float(self.edit_xanes_end.text()), float(self.edit_exafs_end.text()), float(self.edit_preedge_spacing.text()), float(self.edit_xanes_spacing.text()), float(self.edit_exafs_spacing.text()), float(self.edit_preedge_dwell.text()), float(self.edit_xanes_dwell.text()), float(self.edit_exafs_dwell.text()), int(self.comboBox_exafs_dwell_kpower.currentText())) #print(energy_grid) plan_func = self.plan_funcs[plan_key] LivePlots = [ XASPlot(self.apb.ch1_mean.name, self.apb.ch2_mean.name, 'Transmission', self.hhm[0].energy.name, log=True, ax=self.figure.ax1, color='b'), XASPlot(self.apb.ch2_mean.name, self.apb.ch3_mean.name, 'Reference', self.hhm[0].energy.name, log=True, ax=self.figure.ax1, color='r'), XASPlot(self.apb.ch4_mean.name, self.apb.ch1_mean.name, 'Fluorescence', self.hhm[0].energy.name, log=False, ax=self.figure.ax1, color='g'), ] print(f'Edge at execution {self.edge}') RE_args = [ plan_func(**run_parameters, ignore_shutter=ignore_shutter, energy_grid=energy_grid, time_grid=time_grid, element=self.element, e0=self.e0, edge=self.edge, ax=self.figure.ax1, stdout=self.parent_gui.emitstream_out) ] if plan_key.lower() == 'step scan': RE_args.append(LivePlots) self.run_mode_uids = self.RE(*RE_args) timenow = datetime.datetime.now() print('Scan complete at {}'.format(timenow.strftime("%H:%M:%S"))) stop_scan_timer = timer() print('Scan duration {} s'.format(stop_scan_timer - start_scan_timer)) if self.rr_token is not None: self.RE.unsubscribe(self.rr_token) else: message_box('Error', 'Please provide the name for the scan')
def update_xia_graph(self, value, **kwargs): curr_name = kwargs['obj'].name curr_index = -1 if len(self.figure_xia_all_graphs.ax.lines): if float(self.edit_xia_energy_range.text( )) != self.figure_xia_all_graphs.ax.lines[0].get_xdata()[-1]: self.figure_xia_all_graphs.ax.clear() for roi in range(12): if hasattr(self.figure_xia_all_graphs.ax, 'roi{}l'.format(roi)): exec('del self.figure_xia_all_graphs.ax.roi{}l,\ self.figure_xia_all_graphs.ax.roi{}h'.format( roi, roi)) update_figure([self.figure_xia_all_graphs.ax], self.toolbar_xia_all_graphs, self.canvas_xia_all_graphs) self.xia_graphs_names.clear() self.xia_graphs_labels.clear() self.canvas_xia_all_graphs.draw_idle() if curr_name in self.xia_graphs_names: for index, name in enumerate(self.xia_graphs_names): if curr_name == name: curr_index = index line = self.figure_xia_all_graphs.ax.lines[curr_index] line.set_ydata(value) break else: ch_number = curr_name.split('_')[1].split('mca')[1] if ch_number in self.xia_tog_channels: self.xia_graphs_names.append(curr_name) label = 'Chan {}'.format(ch_number) self.xia_graphs_labels.append(label) handles, = self.figure_xia_all_graphs.ax.plot(np.linspace( 0, float(self.edit_xia_energy_range.text()), 2048), value, label=label) self.xia_handles.append(handles) self.figure_xia_all_graphs.ax.legend(self.xia_handles, self.xia_graphs_labels) if len(self.figure_xia_all_graphs.ax.lines) == len( self.xia_tog_channels) != 0: for roi in range(12): exec( 'roi{}x = [float(self.edit_roi_from_{}.text()), float(self.edit_roi_to_{}.text())]' .format(roi, roi, roi)) for roi in range(12): if not hasattr(self.figure_xia_all_graphs.ax, 'roi{}l'.format(roi)): exec( 'self.figure_xia_all_graphs.ax.roi{}l = self.figure_xia_all_graphs.ax.axvline(x=roi{}x[0], color=self.roi_colors[roi])' .format(roi, roi)) exec( 'self.figure_xia_all_graphs.ax.roi{}h = self.figure_xia_all_graphs.ax.axvline(x=roi{}x[1], color=self.roi_colors[roi])' .format(roi, roi)) self.figure_xia_all_graphs.ax.grid(True) self.figure_xia_all_graphs.ax.relim() self.figure_xia_all_graphs.ax.autoscale(True, True, True) y_interval = self.figure_xia_all_graphs.ax.get_yaxis( ).get_data_interval() ''' if len(y_interval): if y_interval[0] != 0 or y_interval[1] != 0: self.figure_xia_all_graphs.ax.set_ylim([y_interval[0] - (y_interval[1] - y_interval[0]) * 0.05, y_interval[1] + (y_interval[1] - y_interval[0]) * 0.05]) ''' self.canvas_xia_all_graphs.draw_idle()
def start_gen_scan_figure(self): update_figure([self.figure_gen_scan.ax], self.toolbar_gen_scan, self.canvas_gen_scan)
def erase_plots(self): update_figure([self.figure_interpolated_scans.ax], self.toolbar_interpolated_scans, self.canvas_interpolated_scans) update_figure([self.figure_binned_scans.ax], self.toolbar_binned_scans, self.canvas_binned_scans)