pyTEMlib 0.2023.8.0__py2.py3-none-any.whl → 0.2024.2.0__py2.py3-none-any.whl

pyTEMlib/eels_dialog_utilities.py

@@ -6,23 +6,18 @@ Author: Gerd Duscher
 """
 
 import numpy as np
-Qt_available = True
-try:
-    from PyQt5 import QtCore, QtGui, QtWidgets
-
-except:
-    Qt_available = False
-    # print('Qt dialogs are not available')
 
 import sidpy
+import matplotlib
+import matplotlib.pyplot as plt
+
 import matplotlib.patches as patches
 from matplotlib.widgets import RectangleSelector, SpanSelector
 
 import h5py  # TODO: needs to go
-import matplotlib.pyplot as plt
 
 from IPython.display import display
-import ipywidgets as widgets
+import ipywidgets
 
 from pyTEMlib import eels_tools as eels
 from pyTEMlib import file_tools as ft
@@ -32,319 +27,6 @@ all_edges = ['K1', 'L1', 'L2', 'L3', 'M1', 'M2', 'M3', 'M4', 'M5', 'N1', 'N2', '
              'O3', 'O4', 'O5', 'O6', 'O7', 'P1', 'P2', 'P3']
 first_close_edges = ['K1', 'L3', 'M5', 'M3', 'N5', 'N3']
 
-if Qt_available:
-
-    class PeriodicTableDialog(QtWidgets.QDialog):
-        """ Modal dialog to get a selection of elements.
-
-        Elements that are not having a valid cross-sections are disabled.
-
-        Parameters
-        ----------
-        initial_elements: list of str
-            the elements that are already selected
-        energy_scale: list or numpy array
-            energy-scale of spectrum/spectra to determine likely edges
-
-        Returns
-        -------
-        list of strings: elements.
-
-        Example
-        -------
-        >> PT_dialog =  periodic_table_dialog(None, ['Mn', 'O'])
-        >> if PT_dialog.exec_() == periodic_table_dialog.Accepted:
-        >>     selected_elements = PT_dialog.get_output()
-        >> print(selected_elements)
-        """
-
-        signal_selected = QtCore.pyqtSignal(list)
-
-        def __init__(self, initial_elements=None, energy_scale=None, parent=None):
-            super(PeriodicTableDialog, self).__init__(None, QtCore.Qt.WindowStaysOnTopHint)
-
-            if initial_elements is None:
-                initial_elements = [' ']
-            self.initial_elements = initial_elements
-            if energy_scale is None:
-                energy_scale = [100., 150., 200.]
-            self.parent = parent
-            self._output = []
-            self.elements_selected = initial_elements
-            self.energy_scale = np.array(energy_scale)
-
-            self.setWindowTitle("Periodic Table")
-            likely_edges = get_likely_edges(self.energy_scale)
-            self.likely_edges = likely_edges
-
-            # GD:font = wx.Font(10, wx.MODERN, wx.NORMAL, wx.BOLD)
-            self.buttons1 = []
-            self.button = []
-            self.pt_info = get_periodic_table_info()
-            self.init_ui()
-
-            for button in self.button:
-                if button.text() in initial_elements:
-                    button.toggle()
-                pass
-
-        def on_close(self):
-            self.get_output()
-            self.signal_selected[list].emit(self._output)
-            self.accept()
-
-        def get_output(self):
-            self._output = []
-            for btn in self.button:
-                if btn.isChecked():
-                    self._output.append(btn.text())
-
-        def exec_(self):
-            super(PeriodicTableDialog, self).exec_()
-            return self._output
-
-        def init_ui(self):
-
-            v_sizer = QtWidgets.QVBoxLayout()
-            g_sizer = QtWidgets.QGridLayout()
-
-            main_group = QtWidgets.QWidget()
-
-            color1 = "background-color: lightblue;\n"
-            color1l = "background-color: dodgerblue;\n"
-            color2 = "background-color: coral;\n"
-
-            for symbol, parameter in self.pt_info.items():
-                self.button.append(QtWidgets.QPushButton(symbol))
-                if parameter['PT_row'] > 7:
-                    self.button[-1].setStyleSheet(color2)
-                elif '*' in symbol:
-                    self.button[-1].setStyleSheet(color2)
-                else:
-                    if symbol in self.likely_edges:
-                        self.button[-1].setStyleSheet(color1l)
-                    else:
-                        self.button[-1].setStyleSheet(color1)
-                if parameter['Z'] == 0:
-                    self.button[-1].setEnabled(False)
-                self.button[-1].setFixedWidth(50)
-                self.button[-1].setCheckable(True)
-                g_sizer.addWidget(self.button[-1], parameter['PT_row'], parameter['PT_col'])
-            main_group.setLayout(g_sizer)
-
-            v_sizer.addWidget(main_group)
-            self.setLayout(v_sizer)
-
-            ok_button = QtWidgets.QPushButton('OK')
-            ok_button.clicked.connect(self.on_close)
-
-            v_sizer.addWidget(ok_button)
-            self.setLayout(v_sizer)
-
-
-    class EnergySelector(QtWidgets.QDialog):
-        """Dialog and cursor to set energy scale"""
-
-        signal_selected = QtCore.pyqtSignal(bool)
-
-        def __init__(self, dset=None):
-            super(EnergySelector, self).__init__(None, QtCore.Qt.WindowStaysOnTopHint)
-
-            if not isinstance(dset, sidpy.Dataset):
-                return
-            if dset is None:
-                return
-            if dset.view is None:
-                return
-            self.dataset = dset
-
-            if hasattr(dset.view, 'axis'):
-                self.axis = dset.view.axis
-                # self.setWindowTitle('p')
-            elif hasattr(dset.view, 'axes'):
-                self.axis = dset.view.axes[1]
-            else:
-                return
-
-            self.spec_dim = -1
-            for dim, axis in self.dataset._axes.items():
-                if axis.dimension_type == sidpy.DimensionType.SPECTRAL:
-                    self.spec_dim = dim
-            if self.spec_dim < 0:
-                raise TypeError('We need at least one SPECTRAL dimension')
-
-            self.energy_scale = self.dataset._axes[self.spec_dim].values
-            self.dispersion = self.energy_scale[1] - self.energy_scale[0]
-            self.offset = self.energy_scale[0]
-            self.spectrum = np.zeros(2)
-
-            self.change = 0
-
-            self.x_min = self.energy_scale[int(len(self.energy_scale)/4)]
-            self.x_max = self.energy_scale[int(len(self.energy_scale) / 4*3)]
-            self.setWindowTitle("Select Energy")
-
-            valid_float = QtGui.QDoubleValidator()
-
-            layout = QtWidgets.QGridLayout()
-            layout.setVerticalSpacing(2)
-            self.label1 = QtWidgets.QLabel('Start:')
-            self.edit1 = QtWidgets.QLineEdit('0')
-            self.edit1.setValidator(valid_float)
-            self.unit1 = QtWidgets.QLabel('eV')
-
-            self.label2 = QtWidgets.QLabel('End:')
-            self.edit2 = QtWidgets.QLineEdit('0')
-            self.edit2.setValidator(valid_float)
-            self.unit2 = QtWidgets.QLabel('eV')
-
-            self.label3 = QtWidgets.QLabel('Dispersion:')
-            self.edit3 = QtWidgets.QLineEdit('0')
-            self.edit3.setValidator(valid_float)
-            self.unit3 = QtWidgets.QLabel('eV')
-
-            self.edit1.editingFinished.connect(self.on_enter)
-            self.edit2.editingFinished.connect(self.on_enter)
-            self.edit3.editingFinished.connect(self.on_enter)
-
-            layout.addWidget(self.label1, 0, 0)
-            layout.addWidget(self.edit1, 0, 1)
-            layout.addWidget(self.unit1, 0, 2)
-
-            layout.addWidget(self.label2, 1, 0)
-            layout.addWidget(self.edit2, 1, 1)
-            layout.addWidget(self.unit2, 1, 2)
-
-            layout.addWidget(self.label3, 2, 0)
-            layout.addWidget(self.edit3, 2, 1)
-            layout.addWidget(self.unit3, 2, 2)
-
-            self.ok_button = QtWidgets.QPushButton('OK')
-            self.ok_button.clicked.connect(self.on_close)
-            self.cancel_button = QtWidgets.QPushButton('Cancel')
-            self.cancel_button.clicked.connect(self.on_close)
-
-            layout.addWidget(self.ok_button, 3, 0)
-            layout.addWidget(self.cancel_button, 3, 2)
-
-            self.setLayout(layout)
-            self.edit1.setFocus()
-            self.plot()
-
-            self.selector = SpanSelector(self.axis, self.line_select_callback,
-                                         direction="horizontal",
-                                         interactive=True,
-                                         props=dict(facecolor='blue', alpha=0.2))
-            self.edit1.setText(f'{self.x_min:.3f}')
-            self.edit2.setText(f'{self.x_max:.3f}')
-            self.edit3.setText(f'{self.dispersion:.4f}')
-            self.update()
-
-        def line_select_callback(self, eclick, erelease):
-            y_min, y_max = self.axis.get_ylim()
-            self.x_min = self.selector.extents[0]
-            self.x_max = self.selector.extents[1]
-            # self.selector.extents = (self.x_min, self.x_max, y_min, y_max)
-
-            self.edit1.setText(f'{self.x_min:.3f}')
-            self.edit2.setText(f'{self.x_max:.3f}')
-
-        def on_enter(self):
-            sender = self.sender()
-
-            if sender == self.edit1:
-                value = float(str(sender.displayText()).strip())
-                if value == self.x_min:
-                    return
-                self.change = value - self.x_min
-                self.x_min += self.change
-                self.x_max += self.change
-                self.offset += self.change
-
-                self.edit1.setText(f"{self.x_min:.2f}")
-                self.edit2.setText(f"{self.x_max:.2f}")
-
-                self.energy_scale = np.arange(len(self.energy_scale)) * self.dispersion + self.offset
-
-                self.update()
-                # self.axis.draw()
-                # self.setWindowTitle(f'shift, {self.change}, {self.x_min}')
-
-            elif sender == self.edit2:
-                value = float(str(sender.displayText()).strip())
-                if value == self.x_max:
-                    return
-                start_channel = np.searchsorted(self.energy_scale, self.x_min)
-                end_channel = np.searchsorted(self.energy_scale, self.x_max)
-
-                self.x_max = value
-
-                if end_channel - start_channel != 0:
-                    self.dispersion = (self.x_max - self.x_min) / (end_channel - start_channel)
-                self.offset = self.x_min - start_channel * self.dispersion
-                self.edit2.setText(f"{self.x_max:.3f}")
-                self.edit3.setText(f"{self.dispersion:.4f}")
-                self.energy_scale = np.arange(len(self.energy_scale)) * self.dispersion + self.offset
-
-                self.update()
-                # self.axis.draw()
-                # self.setWindowTitle(f'range, {self.change}, {self.dispersion}')
-
-            elif sender == self.edit3:
-                value = float(str(sender.displayText()).strip())
-                if self.dispersion == value:
-                    return
-
-                start_channel = np.searchsorted(self.energy_scale, self.x_min)
-                end_channel = np.searchsorted(self.energy_scale, self.x_max)
-                self.dispersion = value
-                self.energy_scale = np.arange(len(self.energy_scale)) * self.dispersion + self.offset
-                self.x_min = self.energy_scale[start_channel]
-                self.x_max = self.energy_scale[end_channel]
-                self.update()
-                # self.axis.draw()
-                self.edit3.setText(f"{self.dispersion:.3f}")
-                self.change = 0
-
-        def on_close(self):
-            sender = self.sender()
-            if sender == self.ok_button:
-                pass
-                self.dataset.set_dimension(self.spec_dim, sidpy.Dimension(self.energy_scale, name='energy_scale',
-                                                                          units='eV', quantity='energy loss',
-                                                                          dimension_type='spectral'))
-            else:
-                pass
-            self.selector.set_visible(False)
-            self.signal_selected[bool].emit(True)
-            self.accept()
-
-        def plot(self):
-            if self.dataset.data_type == sidpy.DataType.SPECTRAL_IMAGE:
-                self.spectrum = self.dataset.view.get_spectrum()
-            else:
-                self.spectrum = np.array(self.dataset)
-            x_limit = self.axis.get_xlim()
-            y_limit = self.axis.get_ylim()
-
-            self.axis.clear()
-            self.cplot = self.axis.plot(self.energy_scale, self.spectrum, label='spectrum')
-            self.axis.set_xlim(x_limit)
-            self.axis.set_ylim(y_limit)
-
-            self.axis.figure.canvas.draw()
-
-        def update(self):
-            x_limit = self.axis.get_xlim()
-            y_limit = self.axis.get_ylim()
-            self.selector.extents = (self.x_min, self.x_max)
-
-            x_limit = np.array(x_limit) + self.change
-
-            self.cplot[0].set_data(self.energy_scale, self.spectrum)
-            self.axis.set_xlim(x_limit)
-            self.axis.set_ylim(y_limit)
-            self.axis.figure.canvas.draw()
 
 
 class RegionSelector(object):
@@ -553,6 +235,201 @@ def get_likely_edges(energy_scale):
 
     return likely_edges
 
+        
+class SpectrumPlot(sidpy.viz.dataset_viz.CurveVisualizer):
+    def __init__(self, dset, spectrum_number=0, figure=None, **kwargs):
+        with plt.ioff():
+            self.figure = plt.figure()
+        self.figure.canvas.toolbar_position = 'right'
+        self.figure.canvas.toolbar_visible = True
+
+        super().__init__(dset, spectrum_number=spectrum_number, figure=self.figure, **kwargs)
+        try:
+            self.dataset = self.dset
+        except:
+            pass
+        self.start_cursor = ipywidgets.FloatText(value=0, description='Start:', disabled=False, color='black', layout=ipywidgets.Layout(width='200px'))
+        self.end_cursor = ipywidgets.FloatText(value=0, description='End:', disabled=False, color='black', layout=ipywidgets.Layout(width='200px'))
+        self.panel = ipywidgets.VBox([ipywidgets.HBox([ipywidgets.Label('',layout=ipywidgets.Layout(width='100px')), ipywidgets.Label('Cursor:'),
+                                                       self.start_cursor,ipywidgets.Label('eV'), 
+                                                       self.end_cursor, ipywidgets.Label('eV')]),
+                                      self.figure.canvas])
+        
+        self.selector = matplotlib.widgets.SpanSelector(self.axis, self.line_select_callback,
+                                         direction="horizontal",
+                                         interactive=True,
+                                         props=dict(facecolor='blue', alpha=0.2))
+        
+    def line_select_callback(self, x_min, x_max):
+        self.start_cursor.value = np.round(x_min, 3)
+        self.end_cursor.value = np.round(x_max, 3)
+        self.start_channel = np.searchsorted(self.dataset.energy_loss, self.start_cursor.value)
+        self.end_channel = np.searchsorted(self.dataset.energy_loss, self.end_cursor.value)
+    
+    def plot(self, scale=True, additional_spectra=None):
+        self.dataset = self.dset
+        self.energy_scale = self.dataset.energy_loss.values
+        x_limit = self.axis.get_xlim()
+        y_limit = np.array(self.axis.get_ylim())
+        
+        self.axis.clear()
+
+        self.axis.plot(self.energy_scale, self.dataset*self.y_scale, label='spectrum')
+                
+        if additional_spectra is not None:
+            if isinstance(additional_spectra, dict):
+                for key, spectrum in additional_spectra.items():
+                    self.axis.plot(self.energy_scale, spectrum*self.y_scale, label=key)
+
+        self.axis.set_xlabel(self.dataset.labels[0])
+        self.axis.set_ylabel(self.dataset.data_descriptor)
+        self.axis.ticklabel_format(style='sci', scilimits=(-2, 3))
+        if scale:
+            self.axis.set_ylim(np.array(y_limit)*self.change_y_scale)
+        
+        self.change_y_scale = 1.0
+        if self.y_scale != 1.:
+                self.axis.set_ylabel('scattering probability (ppm/eV)')
+        self.selector = matplotlib.widgets.SpanSelector(self.axis, self.line_select_callback,
+                                         direction="horizontal",
+                                         interactive=True,
+                                         props=dict(facecolor='blue', alpha=0.2))
+        self.axis.legend()
+        self.figure.canvas.draw_idle()
+        
+
+class SIPlot(sidpy.viz.dataset_viz.SpectralImageVisualizerBase):
+    def __init__(self, dset, figure=None, horizontal=True, **kwargs):
+        if figure is None:
+            with plt.ioff():
+                self.figure = plt.figure()
+        else:
+            self.figure = figure
+        self.figure.canvas.toolbar_position = 'right'
+        self.figure.canvas.toolbar_visible = True
+        self.dset = dset
+        super().__init__(self.dset, figure=self.figure, horizontal=horizontal, **kwargs)
+        
+        self.start_cursor = ipywidgets.FloatText(value=0, description='Start:', disabled=False, color='black', layout=ipywidgets.Layout(width='200px'))
+        self.end_cursor = ipywidgets.FloatText(value=0, description='End:', disabled=False, color='black', layout=ipywidgets.Layout(width='200px'))
+        self.panel = ipywidgets.VBox([ipywidgets.HBox([ipywidgets.Label('',layout=ipywidgets.Layout(width='100px')), ipywidgets.Label('Cursor:'),
+                                                       self.start_cursor,ipywidgets.Label('eV'), 
+                                                       self.end_cursor, ipywidgets.Label('eV')]),
+                                      self.figure.canvas])
+        self.axis = self.axes[-1]
+        self.selector = matplotlib.widgets.SpanSelector(self.axis, self.line_select_callback,
+                                         direction="horizontal",
+                                         interactive=True,
+                                         props=dict(facecolor='blue', alpha=0.2))
+       
+    def line_select_callback(self, x_min, x_max):
+        self.start_cursor.value = np.round(x_min, 3)
+        self.end_cursor.value = np.round(x_max, 3)
+        self.start_channel = np.searchsorted(self.dataset.energy_loss, self.start_cursor.value)
+        self.end_channel = np.searchsorted(self.dataset.energy_loss, self.end_cursor.value)
+    
+    def plot(self, scale=True, additional_spectra=None):
+        
+        xlim = self.axes[1].get_xlim()
+        ylim = self.axes[1].get_ylim()
+        self.axes[1].clear()
+        self.get_spectrum()
+        if len(self.energy_scale)!=self.spectrum.shape[0]:
+            self.spectrum = self.spectrum.T
+        self.axes[1].plot(self.energy_scale, self.spectrum.compute(), label='experiment')
+        if additional_spectra is not None:
+            if isinstance(additional_spectra, dict):
+                for key, spectrum in additional_spectra.items():
+                    self.axes[1].plot(self.energy_scale, spectrum, label=key)
+
+        if self.set_title:
+            self.axes[1].set_title('spectrum {}, {}'.format(self.x, self.y))
+        self.fig.tight_layout()
+        self.selector = matplotlib.widgets.SpanSelector(self.axes[1], self.line_select_callback,
+                                         direction="horizontal",
+                                         interactive=True,
+                                         props=dict(facecolor='blue', alpha=0.2))
+        
+        self.axes[1].set_xlim(xlim)
+        self.axes[1].set_ylim(ylim)
+        self.axes[1].set_xlabel(self.xlabel)
+        self.axes[1].set_ylabel(self.ylabel)
+
+        self.fig.canvas.draw_idle()
+
+
+def get_periodic_table_widget(energy_scale=None):
+
+    if energy_scale is None:
+        energy_scale = [100., 150., 200.]
+    
+    likely_edges = get_likely_edges(energy_scale)
+    
+    pt_info =  get_periodic_table_info()
+    table = ipywidgets.GridspecLayout(10, 18,width= '60%', grid_gap="0px")
+    for symbol, parameter in pt_info.items():
+        #print(parameter['PT_row'], parameter['PT_col'])
+        if parameter['PT_row'] > 7:
+            color = 'warning'
+        elif '*' in symbol:
+            color = 'warning'
+        else:
+            if symbol in likely_edges:
+                color = 'primary'
+            else:
+                color = 'info'
+        table[parameter['PT_row'], parameter['PT_col']] = ipywidgets.ToggleButton(description=symbol, 
+                                                                                  value=False, 
+                                                                                  button_style=color,
+                                                                                  layout=ipywidgets.Layout(width='auto'),
+                                                                                  style={"button_width": "30px"})
+    return table
+
+
+class PeriodicTableWidget(object):
+    """ ipywidget to get a selection of elements.
+
+    Elements that are not having a valid cross-sections are disabled.
+
+    Parameters
+    ----------
+    initial_elements: list of str
+        the elements that are already selected
+    energy_scale: list or numpy array
+        energy-scale of spectrum/spectra to determine likely edges
+
+    Returns
+    -------
+    list of strings: elements.
+        use get_output() function
+    """
+
+    def __init__(self, initial_elements=None, energy_scale=None):
+
+        if initial_elements is None:
+            initial_elements = [' ']
+        self.elements_selected = initial_elements
+        if energy_scale is None:
+            energy_scale = [100., 150., 200.]
+        self._output = []
+        self.energy_scale = np.array(energy_scale)
+        self.pt_info =  get_periodic_table_info()
+    
+        self.periodic_table = get_periodic_table_widget(energy_scale) 
+        self.update()
+
+    def get_output(self):
+        self.elements_selected = []
+        for symbol, parameter in self.pt_info.items():
+            if self.periodic_table[parameter['PT_row'], parameter['PT_col']].value == True:  # [parameter['PT_row'], parameter['PT_col']]
+                self.elements_selected.append(self.periodic_table[parameter['PT_row'], parameter['PT_col']].description)
+        return self.elements_selected
+    
+    def update(self):
+        for symbol, parameter in self.pt_info.items():
+            if str(self.periodic_table[parameter['PT_row'], parameter['PT_col']].description) in list(self.elements_selected):
+                self.periodic_table[parameter['PT_row'], parameter['PT_col']].value = True
+
 
 
 
@@ -651,15 +528,15 @@ class InteractiveSpectrumImage(object):
 
     def __init__(self, data_source, horizontal=True):
 
-        box_layout = widgets.Layout(display='flex',
+        box_layout = ipywidgets.Layout(display='flex',
                                     flex_flow='row',
                                     align_items='stretch',
                                     width='100%')
 
         words = ['fix_energy', 'fit_zero_loss', 'fit_low_loss', 'fit_composition', 'fit_ELNES']
 
-        self.buttons = [widgets.ToggleButton(value=False, description=word, disabled=False) for word in words]
-        box = widgets.Box(children=self.buttons, layout=box_layout)
+        self.buttons = [ipywidgets.ToggleButton(value=False, description=word, disabled=False) for word in words]
+        box = ipywidgets.Box(children=self.buttons, layout=box_layout)
         display(box)
 
         # MAKE Dictionary
@@ -1198,13 +1075,13 @@ class EdgesAtCursor(object):
 
 
 def make_box_layout():
-    return widgets.Layout(border='solid 1px black', margin='0px 10px 10px 0px', padding='5px 5px 5px 5px')
+    return ipywidgets.Layout(border='solid 1px black', margin='0px 10px 10px 0px', padding='5px 5px 5px 5px')
     
 
-class plot_EELS(widgets.HBox):
+class plot_EELS(ipywidgets.HBox):
     def __init__(self, dataset):
         super().__init__()
-        output = widgets.Output()
+        output = ipywidgets.Output()
         self.dataset = dataset
         self.spec_dim = 0
         initial_color = '#FF00DD'
@@ -1226,48 +1103,48 @@ class plot_EELS(widgets.HBox):
         self.fig.canvas.mpl_connect('pick_event', self.on_legend_pick)
         
         # define widgets
-        int_slider = widgets.IntSlider(
+        int_slider = ipywidgets.IntSlider(
             value=1, 
             min=0, 
             max=10, 
             step=1, 
             description='freq'
         )
-        self.offset = widgets.Text(
+        self.offset = ipywidgets.Text(
             value='0', 
             width=5,
             description='offset', 
             continuous_update=False
         )
-        self.dispersion = widgets.Text(
+        self.dispersion = ipywidgets.Text(
             value='0', 
             width=5,
             description='dispersion', 
             continuous_update=False
         )
 
-        self.exposure = widgets.Text(
+        self.exposure = ipywidgets.Text(
             value='0', 
             width=5,
             description='exposure', 
             continuous_update=False
         )
         
-        button_energy_scale = widgets.Button(description='Cursor')
-        button_elements_at_cursor = widgets.Button(description='Elements Cursor')
-        button_main_elements = widgets.Button(description='Main Elements')
+        button_energy_scale = ipywidgets.Button(description='Cursor')
+        button_elements_at_cursor = ipywidgets.Button(description='Elements Cursor')
+        button_main_elements = ipywidgets.Button(description='Main Elements')
         
-        controls = widgets.VBox([
-            widgets.HBox([self.offset, widgets.Label('eV')]),
-            widgets.HBox([self.dispersion, widgets.Label('eV/channel')]),
-            widgets.HBox([self.exposure, widgets.Label('s')]),
+        controls = ipywidgets.VBox([
+            ipywidgets.HBox([self.offset, ipywidgets.Label('eV')]),
+            ipywidgets.HBox([self.dispersion, ipywidgets.Label('eV/channel')]),
+            ipywidgets.HBox([self.exposure, ipywidgets.Label('s')]),
             button_energy_scale,
-            widgets.HBox([button_elements_at_cursor, button_main_elements])
+            ipywidgets.HBox([button_elements_at_cursor, button_main_elements])
         ])
             
         controls.layout = make_box_layout()
          
-        out_box = widgets.Box([output])
+        out_box = ipywidgets.Box([output])
         output.layout = make_box_layout()
  
         # observe stuff