def plot_avg_xas_single(bin_xas, detector):
plotview = NXPlotView()
if detector == "I0":
y_array = bin_xas.i0
elif detector == "TEY":
y_array = bin_xas.tey
elif detector == "DIODE" or detector == "PD1":
y_array = bin_xas.diode
elif detector == "PFY_SDD1":
y_array = bin_xas.pfy_sdd1
elif detector == "PFY_SDD2":
y_array = bin_xas.pfy_sdd2
elif detector == "PFY_SDD3":
y_array = bin_xas.pfy_sdd3
elif detector == "PFY_SDD4":
y_array = bin_xas.pfy_sdd4
else:
return "Invalid dividend name"
plotview.figure.clf()
ax = plotview.figure.gca()
ax.axes.get_xaxis().set_visible(True)
ax.axes.get_yaxis().set_visible(True)
ax.plot(bin_xas.energy, y_array)
ax.set_xlabel('Energy (eV)')
ax.set_ylabel(detector)
plotview.draw()
def eem(multi_xas, name):
start_time = time.time()
# matplotlib.rcParams['figure.figsize'] = (14, 10)
name = name.upper()
if name == "SDD1":
intensity = multi_xas.sdd1
# intensity = np.array(intensity)
elif name == "SDD2":
intensity = multi_xas.sdd2
# intensity = np.array(intensity)
elif name == "SDD3":
intensity = multi_xas.sdd3
# intensity = np.array(intensity)
elif name == "SDD4":
intensity = multi_xas.sdd4
# intensity = np.array(intensity)
else:
return "Invalid name for the intensity of EEM"
energy_array = np.array(multi_xas.energy)
num_of_points = len(energy_array)
num_of_emission_bins = len(intensity[0])
bin_num_for_x = np.zeros(shape=(num_of_points, num_of_emission_bins))
for i in range(num_of_points):
bin_num_for_x[i].fill(energy_array[i])
bin_num_for_y = np.zeros(shape=(num_of_points, num_of_emission_bins))
bin_num_for_y[0:] = np.arange(10, (num_of_emission_bins + 1) * 10, 10)
v_max = max(intensity[0])
for i in range(1, num_of_points):
temp_max = max(intensity[i])
if temp_max > v_max:
v_max = temp_max
# print ("v_max: ", v_max)
intensity = np.array(intensity)
plotview = NXPlotView()
plotview.figure.clf()
ax = plotview.figure.gca()
ax.axes.get_xaxis().set_visible(True)
ax.axes.get_yaxis().set_visible(True)
# print("--- %s seconds ---" % (time.time() - start_time))
ax.scatter(bin_num_for_x,
bin_num_for_y,
c=intensity,
s=7,
linewidths=0,
vmax=v_max,
vmin=0)
print("--- %s seconds ---" % (time.time() - start_time))
ax.set_xlabel('Incident Energy (eV)')
ax.set_ylabel('Emission Energy (eV)')
ax.set_title("Excitation Emission Matrix")
plotview.grid()
plotview.draw()
print("--- %s seconds ---" % (time.time() - start_time))
def plot_normalized(xas, dividend, divisor):
plotview = NXPlotView()
# convert the string to uppercase
dividend = dividend.upper()
divisor = divisor.upper()
if dividend == "I0":
dividend_array = xas.i0
elif dividend == "TEY":
dividend_array = xas.tey
elif dividend == "DIODE" or dividend == "PD1":
dividend_array = xas.diode
elif dividend == "PFY_SDD1":
dividend_array = xas.pfy_sdd1
elif dividend == "PFY_SDD2":
dividend_array = xas.pfy_sdd2
elif dividend == "PFY_SDD3":
dividend_array = xas.pfy_sdd3
elif dividend == "PFY_SDD4":
dividend_array = xas.pfy_sdd4
else:
return "Invalid dividend name"
if divisor == "I0":
divisor_array = xas.i0
elif divisor == "TEY":
divisor_array = xas.tey
elif divisor == "DIODE" or divisor == "PD1":
divisor_array = xas.diode
elif divisor == "PFY_SDD1":
divisor_array = xas.pfy_sdd1
elif divisor == "PFY_SDD2":
divisor_array = xas.pfy_sdd2
elif divisor == "PFY_SDD3":
divisor_array = xas.pfy_sdd3
elif divisor == "PFY_SDD4":
divisor_array = xas.pfy_sdd4
else:
return "Invalid divisor name"
normalized_array = np.array(dividend_array) / np.array(divisor_array)
# the old code using Matplotlib to plot diagrams
# plt.figure()
# plt.plot(xas.energy, normalized_array)
# str_y_axis = StringIO()
# str_y_axis.write(dividend + ' / ' + divisor)
# plt.ylabel(str_y_axis.getvalue())
# plt.title("Averaged %s / Averaged %s" % (dividend, divisor))
plotview.figure.clf()
ax = plotview.figure.gca()
ax.axes.get_xaxis().set_visible(True)
ax.axes.get_yaxis().set_visible(True)
ax.plot(xas.energy, normalized_array)
ax.set_xlabel('Energy (eV)')
str_y_axis = StringIO()
str_y_axis.write(dividend + ' / ' + divisor)
ax.set_ylabel(str_y_axis.getvalue())
ax.set_title("Averaged %s / Averaged %s" % (dividend, divisor))
plotview.draw()
return xas.energy, normalized_array
def plot_avg_xas_all(bin_xas):
"""
Generate all plots (matplotlib figures) for averaged data at once
:return: None
"""
print("Plotting average XAS.")
# matplotlib.rcParams['figure.figsize'] = (14, 22)
plotview = NXPlotView()
plotview.setMinimumHeight(200)
plotview.resize(1400, 800)
plotview.figure.clf()
en = bin_xas.energy
i0 = bin_xas.i0
tey = bin_xas.tey
diode = bin_xas.diode
pfy_sdd1 = bin_xas.pfy_sdd1
pfy_sdd2 = bin_xas.pfy_sdd2
pfy_sdd3 = bin_xas.pfy_sdd3
pfy_sdd4 = bin_xas.pfy_sdd4
plt.subplot(2, 4, 1)
plt.plot(en, tey)
# add lable for x and y axis
plt.xlabel('Energy (eV)')
plt.ylabel('TEY')
# add title of the figure
plt.title('Binned(Averaged) TEY')
plt.subplot(2, 4, 2)
plt.plot(en, i0)
plt.xlabel('Energy (eV)')
plt.ylabel('I0')
plt.title('Binned(Averaged) I0')
plt.subplot(2, 4, 3)
plt.plot(en, diode)
plt.xlabel('Energy (eV)')
plt.ylabel('Diode')
plt.title('Binned(Averaged) Diode')
plt.subplot(2, 4, 5)
plt.plot(en, pfy_sdd1)
plt.xlabel('Energy (eV)')
plt.ylabel('PFY_SDD1')
plt.title('Binned(Averaged) PFY_SDD1')
plt.subplot(2, 4, 6)
plt.plot(en, pfy_sdd2)
plt.xlabel('Energy (eV)')
plt.ylabel('PFY_SDD2')
plt.title('Binned(Averaged) PFY_SDD2')
plt.subplot(2, 4, 7)
plt.plot(en, pfy_sdd3)
plt.xlabel('Energy (eV)')
plt.ylabel('PFY_SDD3')
plt.title('Binned(Averaged) PFY_SDD3')
plt.subplot(2, 4, 8)
plt.plot(en, pfy_sdd4)
plt.xlabel('Energy (eV)')
plt.ylabel('PFY_SDD4')
plt.title('Binned(Averaged) PFY_SDD4')
plt.tight_layout()
# use plotview from Nexpy to generate plots
plotview.figure = plt
plotview.tab_widget.removeTab(0)
plotview.tab_widget.removeTab(0)
plotview.draw()
def summary_plot(self, name):
start_time = time.time()
# matplotlib.rcParams['figure.figsize'] = (13, 10)
# select intensity
name = name.upper()
if name == "TEY":
intensity = self.tey
elif name == "I0" or name == "IO":
intensity = self.i0
elif name == "DIODE" or name == "PD1":
intensity = self.diode
elif name == "PFY_SDD1":
intensity = self.pfy_sdd1
elif name == "PFY_SDD2":
intensity = self.pfy_sdd2
elif name == "PFY_SDD3":
intensity = self.pfy_sdd3
elif name == "PFY_SDD4":
intensity = self.pfy_sdd4
else:
return "Invalid name for the intensity of summary plot"
total_cscan_num = len(self.energy)
# print (total_cscan_num)
# show the plot in Nexpy, similar to figure.show()
plotview = NXPlotView()
# setup the size of figure and pop-up window
plotview.setMinimumHeight(200)
if total_cscan_num > 10:
ratio = total_cscan_num / 10
else:
ratio = 1
plotview.resize(700, 280 * ratio)
plotview.figure.clf()
# setup axis
ax = plotview.figure.gca()
ax.axes.get_xaxis().set_visible(True)
ax.axes.get_yaxis().set_visible(True)
print("--- %s seconds ---" % (time.time() - start_time))
energy_tuple = np.array(self.energy[0][:])
intensity_tuple = np.array(intensity[0][:])
scan_num_tuple = np.zeros(len(self.energy[0]))
scan_num_tuple.fill(1)
# prepare data as tuples for x, y, and color of scatter plot
for i in range(1, total_cscan_num):
scan_num_list = np.zeros(len(self.energy[i]))
scan_num_list.fill(i + 1)
scan_num_tuple = np.concatenate([scan_num_tuple, scan_num_list])
energy_tuple = np.concatenate(
[energy_tuple, np.array(self.energy[i][:])])
intensity_tuple = np.concatenate(
[intensity_tuple, np.array(intensity[i][:])])
# comment out the old way to generate scatter plot
#plt.scatter(self.energy[i][:], scan_num_list, c=intensity[i][:], s=140, linewidths=0, marker='s')
# print("--- %s seconds ---" % (time.time() - start_time))
# main function call to generate color scatter plot
ax.scatter(energy_tuple,
scan_num_tuple,
c=intensity_tuple,
s=140,
linewidths=0,
marker='s')
# this locator puts ticks at regular intervals
loc = plticker.MultipleLocator(base=1.0)
# set regular ticks interval
ax.yaxis.set_major_locator(loc)
# set the limitation of y axis
ax.set_ylim(ymin=0, ymax=total_cscan_num + 1)
# manipulate the ytick labels
t = np.arange(len(self.selected_scan_entry)) + 1.0
ax.set_yticks(t)
ax.set_yticklabels(self.selected_scan_entry)
# add title of the figure
ax.set_title("Summary Plot (Intensity: %s)" % (name))
# add labels for x and y axis
ax.set_xlabel('Incident Energy(eV)')
ax.set_ylabel('Scan Entry')
# set limit of y axis
print("selected_scan_entry: ", self.selected_scan_entry)
plotview.grid(True)
plotview.draw()
print("--- %s seconds ---" % (time.time() - start_time))
class MaskDialog(BaseDialog):
def __init__(self, parent=None):
super(MaskDialog, self).__init__(parent)
self.plotview = None
self.shapes = []
self.select_entry(self.choose_entry)
self.shape_box = self.select_box(['Rectangle', 'Circle'])
self.set_layout(self.entry_layout,
self.make_layout(
self.action_buttons(('Add Shape', self.add_shape)),
self.shape_box),
self.close_buttons(save=True))
self.set_title('Mask Data')
def choose_entry(self):
if 'calibration' not in self.entry['instrument']:
raise NeXusError('Please load calibration data to this entry')
self.data = self.entry['instrument/calibration']
self.counts = self.data.nxsignal.nxvalue
self.mask = self.entry['instrument/detector/pixel_mask'].nxvalue
self.plot_data()
shape = self.data.nxsignal.shape
def plot_data(self):
if self.plotview is None:
if 'Mask Editor' in plotviews:
self.plotview = plotviews['Mask Editor']
else:
self.plotview = NXPlotView('Mask Editor')
self.plotview.plot(self.data, log=True)
self.plotview.aspect='equal'
self.plotview.ytab.flipped = True
self.plotview.draw()
def add_shape(self):
self.plotview.deactivate()
xlo, xhi = self.plotview.xaxis.lo, self.plotview.xaxis.hi
ylo, yhi = self.plotview.yaxis.lo, self.plotview.yaxis.hi
xc, yc = xlo + 0.5 * (xhi - xlo), ylo + 0.5 * (yhi - ylo)
r = (xhi - xlo) / 4
if self.shape_box.currentText() == 'Rectangle':
self.shapes.append(NXrectangle(xc-r, yc-r, 2*r, 2*r,
border_tol=0.1, plotview=self.plotview,
facecolor='r', edgecolor='k',
linewidth=1, alpha=0.3))
else:
self.shapes.append(NXcircle(xc, yc, r, border_tol=0.1,
plotview=self.plotview,
facecolor='r', edgecolor='k',
linewidth=1, alpha=0.3))
self.plotview.draw()
self.shapes[-1].connect()
def accept(self):
x, y = np.arange(self.mask.shape[1]), np.arange(self.mask.shape[0])
for shape in self.shapes:
if isinstance(shape, NXrectangle):
rect = shape.rectangle
x0, y0 = int(rect.get_x()), int(rect.get_y())
x1, y1 = int(x0+rect.get_width()), int(y0+rect.get_height())
self.mask[y0:y1,x0:x1] = 1
else:
circle = shape.circle
xc, yc = circle.center
r = circle.radius
inside = (x[None,:]-int(xc))**2+(y[:,None]-int(yc))**2 < r**2
self.mask = self.mask | inside
self.mask[np.where(self.counts<0)] = 1
self.entry['instrument/detector/pixel_mask'] = self.mask
super(MaskDialog, self).accept()
if 'Mask Editor' in plotviews:
plotviews['Mask Editor'].close_view()
def reject(self):
super(MaskDialog, self).reject()
if 'Mask Editor' in plotviews:
plotviews['Mask Editor'].close_view()
class MaskDialog(NXDialog):
def __init__(self, parent=None):
super().__init__(parent)
self.plotview = None
self.shapes = []
self.parameters = {}
self.select_entry(self.choose_entry)
self.shape_box = self.select_box(['Rectangle', 'Circle'])
self.shape_choice = self.select_box([], slot=self.choose_shape)
self.set_layout(
self.entry_layout,
self.make_layout(
self.action_buttons(('Add Shape', self.add_shape)),
self.shape_box), self.shape_choice,
self.close_buttons(save=True))
self.shape_choice.setVisible(False)
self.set_title('Mask Data')
def choose_entry(self):
if 'calibration' not in self.entry['instrument']:
raise NeXusError('Please load calibration data to this entry')
self.data = self.entry['instrument/calibration']
self.counts = self.data.nxsignal.nxvalue
self.mask = self.entry['instrument/detector/pixel_mask'].nxvalue
self.xc = self.entry['instrument/detector/beam_center_x'].nxvalue
self.yc = self.entry['instrument/detector/beam_center_y'].nxvalue
self.plot_data()
shape = self.data.nxsignal.shape
def plot_data(self):
if self.plotview is None:
if 'Mask Editor' in plotviews:
self.plotview = plotviews['Mask Editor']
else:
self.plotview = NXPlotView('Mask Editor')
self.plotview.plot(self.data, log=True)
self.plotview.aspect = 'equal'
self.plotview.ytab.flipped = True
self.plotview.draw()
def add_shape(self):
if self.shape_box.currentText() == 'Rectangle':
self.shapes.append(
NXrectangle(self.xc - 50,
self.yc - 50,
100,
100,
border_tol=0.1,
plotview=self.plotview,
resize=True,
facecolor='r',
edgecolor='k',
linewidth=1,
alpha=0.3))
else:
self.shapes.append(
NXcircle(self.xc,
self.yc,
50,
border_tol=0.1,
plotview=self.plotview,
resize=True,
facecolor='r',
edgecolor='k',
linewidth=1,
alpha=0.3))
self.plotview.draw()
self.shapes[-1].connect()
self.shape_choice.addItem(repr(self.shapes[-1]))
self.shape_choice.setVisible(True)
self.insert_layout(self.shape_options(self.shapes[-1]))
def shape_options(self, shape):
p = self.parameters[shape] = GridParameters()
if isinstance(shape, NXrectangle):
x, y = shape.xy
w, h = shape.width, shape.height
p.add('x', x, 'Left Pixel')
p.add('y', y, 'Bottom Pixel')
p.add('w', w, 'Width')
p.add('h', h, 'Height')
else:
x, y = shape.center
r = abs(shape.width) / 2
p.add('x', x, 'X-Center')
p.add('y', y, 'Y-Center')
p.add('r', r, 'Radius')
return p.grid(header=False)
def choose_shape(self):
pass
def accept(self):
x, y = np.arange(self.mask.shape[1]), np.arange(self.mask.shape[0])
for shape in self.shapes:
if isinstance(shape, NXrectangle):
x0, y0 = shape.xy
x1, y1 = x0 + shape.width, y0 + shape.height
self.mask[int(y0):int(y1), int(x0):int(x1)] = 1
else:
xc, yc = shape.center
r = shape.radius
inside = (x[None, :] - int(xc))**2 + (y[:, None] -
int(yc))**2 < r**2
self.mask = self.mask | inside
self.mask[np.where(self.counts < 0)] = 1
try:
self.entry['instrument/detector/pixel_mask'] = self.mask
except NeXusError as error:
report_error("Creating Mask", error)
return
super().accept()
if 'Mask Editor' in plotviews:
plotviews['Mask Editor'].close_view()
def reject(self):
super().reject()
if 'Mask Editor' in plotviews:
plotviews['Mask Editor'].close_view()
