def get_xia_energy_grid(e0,
preedge_start,
xanes_start,
xanes_end,
exafs_end,
preedge_spacing,
xanes_spacing,
exafsk_spacing,
int_time_preedge=1,
int_time_xanes=1,
int_time_exafs=1,
k_power=0):
preedge = np.arange(e0 + preedge_start, e0 + xanes_start, preedge_spacing)
preedge_int = np.ones(len(preedge)) * int_time_preedge
edge = np.arange(e0 + xanes_start, e0 + xanes_end, xanes_spacing)
edge_int = np.ones(len(edge)) * int_time_xanes
iterator = exafsk_spacing
kenergy = 0
postedge = np.array([])
energy_end = xray.k2e(exafs_end, e0)
exafs_int = []
while (kenergy + e0 + xanes_end < energy_end):
kenergy = xray.k2e(iterator, e0) - e0
postedge = np.append(postedge, e0 + xanes_end + kenergy)
exafs_int.append(int_time_exafs * (iterator**k_power))
iterator += exafsk_spacing
integration_times = np.append(np.append(preedge_int, edge_int),
np.array(exafs_int))
grid = np.append(np.append(preedge, edge), postedge)
return grid[::-1], integration_times
def energy_grid(self, array, e0, edge_start, edge_end, preedge_spacing, xanes, exafsk):
preedge = np.arange(np.min(array), edge_start, preedge_spacing)
edge = np.arange(edge_start, edge_end, xanes)
eenergy = xray.k2e(xray.e2k(edge_end, e0), e0)
postedge = np.array([])
while(eenergy < np.max(array)):
kenergy = xray.e2k(eenergy, e0)
kenergy += exafsk
eenergy = xray.k2e(kenergy, e0)
postedge = np.append(postedge, eenergy)
return np.append(np.append(preedge, edge), postedge)
def batch_create_trajectories(self):
for i in range(len(self.experiment_table)):
d = self.experiment_table.iloc[i]
traj = trajectory(self.hhm)
kwargs = dict(
edge_energy=d['Position'],
offsets=([
d['pre-edge start'], d['pre-edge stop'],
d['post_edge stop'],
xray.k2e(d['k-range'], d['Position']) - d['Position']
]),
trajectory_type='Double Sine',
dsine_preedge_duration=d['time 1'],
dsine_postedge_duration=d['time 2'],
)
traj.define(**kwargs)
# Add some more parameters manually:
traj.elem = d['Element']
traj.edge = d['Edge']
traj.e0 = d['Position']
traj.interpolate()
traj.revert()
self.trajectories.append(traj)
self.experiments.append(XASExperiment(definition=d))
def get_k_interval(self, energy_array, e0, edge_end, exafsk):
iterator = exafsk
kenergy = 0
postedge = np.array([])
while (kenergy + edge_end < np.max(energy_array)):
kenergy = xray.k2e(iterator, e0) - e0
postedge = np.append(postedge, edge_end + kenergy)
iterator += exafsk
return postedge
def get_xia_energy_grid(e0, preedge_start, xanes_start, xanes_end, exafs_end, preedge_spacing, xanes_spacing, exafsk_spacing, int_time_preedge = 1, int_time_xanes = 1, int_time_exafs = 1, k_power = 0):
preedge = np.arange(e0 + preedge_start, e0 + xanes_start, preedge_spacing)
preedge_int = np.ones(len(preedge)) * int_time_preedge
edge = np.arange(e0 + xanes_start, e0 + xanes_end, xanes_spacing)
edge_int = np.ones(len(edge)) * int_time_xanes
iterator = exafsk_spacing
kenergy = 0
postedge = np.array([])
energy_end = xray.k2e(exafs_end, e0)
exafs_int = []
while(kenergy + e0 + xanes_end < energy_end):
kenergy = xray.k2e(iterator, e0) - e0
postedge = np.append(postedge, e0 + xanes_end + kenergy)
exafs_int.append(int_time_exafs * (iterator ** k_power))
iterator += exafsk_spacing
integration_times = np.append(np.append(preedge_int, edge_int), np.array(exafs_int))
grid = np.append(np.append(preedge, edge), postedge)
return grid[::-1], integration_times
def energy_grid(self, array, e0, edge_start, edge_end, preedge_spacing,
xanes, exafsk):
preedge = np.arange(np.min(array), edge_start, preedge_spacing)
edge = np.arange(edge_start, edge_end, xanes)
iterator = exafsk
kenergy = 0
postedge = np.array([])
while (kenergy + edge_end < np.max(array)):
kenergy = xray.k2e(iterator, e0) - e0
postedge = np.append(postedge, edge_end + kenergy)
iterator += exafsk
return np.append(np.append(preedge, edge), postedge)
def mouse_press_event(self, event):
e_vs_k_discriminate_list = [
'pushButton_spline_lo_set', 'pushButton_spline_hi_set',
'pushButton_k_ft_lo_set', 'pushButton_k_ft_hi_set'
]
lineEdit = getattr(
self, self.pushButton_set_to_lineEdit_dict[self.sender_object])
e0 = float(self.lineEdit_e0.text())
if self.sender_object == 'pushButton_e0_set':
new_value = event.xdata
elif self.sender_object == 'pushButton_truncate_at_set':
if self.current_plot_in == 'e':
new_value = event.xdata
elif self.current_plot_in == 'k':
new_value = k2e(event.xdata, e0)
elif self.sender_object in e_vs_k_discriminate_list:
if self.current_plot_in == 'k':
new_value = event.xdata
elif self.current_plot_in == 'e':
new_value = e2k(event.xdata, e0)
else:
new_value = event.xdata - e0
lineEdit.setText('{:.1f}'.format(new_value))
sender_object = lineEdit
print(sender_object)
selection = self.listView_xasproject.selectedIndexes()
if selection != []:
index = selection[0].row()
ds = self.xasproject[index]
try:
float(sender_object.text())
setattr(
ds, self.lineEdit_to_ds_parameter_dict[
sender_object.objectName()],
float(sender_object.text()))
except:
print('what' 's going wrong')
self._disconnect_cid()
def create_new_trajectory(
self, traj_signature, traj_index
): # creates, saves, loads, and initializes trajectory with this signature
trajectory_creator = TrajectoryCreator(self.hhm.servocycle,
self.hhm.pulses_per_deg)
if traj_signature['type'] == 'Double Sine':
trajectory_creator.elem = traj_signature['parameters']['element']
trajectory_creator.edge = traj_signature['parameters']['edge']
trajectory_creator.e0 = str(traj_signature['parameters']['E0'])
preedge_lo = traj_signature['parameters']['Epreedge']
postedge_hi = xray.k2e(traj_signature['parameters']['kmax'],
traj_signature['parameters']
['E0']) - traj_signature['parameters']['E0']
trajectory_creator.define(
edge_energy=traj_signature['parameters']['E0'],
offsets=[preedge_lo, -30, 50, postedge_hi],
dsine_preedge_duration=traj_signature['parameters']['t1'],
dsine_postedge_duration=traj_signature['parameters']['t2'],
trajectory_type='Double Sine')
else:
raise KeyError(
'this type of trajectory is not currently supported')
trajectory_creator.interpolate()
trajectory_creator.revert()
fname = traj_signature['parameters']['element'] + '_' + str(
uuid.uuid4())[:8] + '.txt'
fpath = self.hhm.traj_filepath + fname
trajectory_creator.save(fpath)
self.trajectory_manager.load(orig_file_name=fname,
new_file_path=traj_index + 1,
is_energy=True,
offset=self.hhm.angle_offset.value)
self.trajectory_manager.init(traj_index + 1)
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
self.figure_single_trajectory.ax.clear()
self.figure_single_trajectory.ax2.clear()
self.toolbar_single_trajectory._views.clear()
self.toolbar_single_trajectory._positions.clear()
self.toolbar_single_trajectory._update_view()
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
self.figure_full_trajectory.ax.clear()
self.toolbar_full_trajectory._views.clear()
self.toolbar_full_trajectory._positions.clear()
self.toolbar_full_trajectory._update_view()
self.canvas_full_trajectory.draw_idle()
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)
