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)
