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

pyTEMlib/peak_dialog.py

@@ -24,6 +24,7 @@ import sidpy
 import pyTEMlib.file_tools as ft
 from pyTEMlib import  eels_tools
 from pyTEMlib import peak_dlg
+from pyTEMlib import eels_dialog_utilities
 
 advanced_present = True
 try:
@@ -85,7 +86,7 @@ def get_sidebar():
                      style=ipywidgets.ButtonStyle(button_color='lightblue'))
     row += 1
     side_bar[row, :2] = ipywidgets.Dropdown(
-            options=[('Peak 1', 0), ('Add Peak', -1)],
+            options=[('Peak 1', 0), ('add peak', -1)],
             value=0,
             description='Peaks:',
             disabled=False,
@@ -138,22 +139,14 @@ class PeakFitWidget(object):
     def __init__(self, datasets=None):
         self.datasets = datasets
         if not isinstance(datasets, dict):
-            raise TypeError('dataset or first item inhas to be a sidpy dataset')
+            raise TypeError('need dictioary of sidpy datasets')
             
         self.sidebar = get_sidebar()
         self.key = list(self.datasets)[0]
         self.dataset = datasets[self.key]
         if not isinstance(self.dataset, sidpy.Dataset):
             raise TypeError('dataset or first item inhas to be a sidpy dataset')
-        self.spec_dim = ft.get_dimensions_by_type('spectral', self.dataset)
-        if len(self.spec_dim) != 1:
-            raise TypeError('We need exactly one SPECTRAL dimension')
-        self.spec_dim = self.spec_dim[0]
-        #self.energy_scale = self.dataset._axes[self.spec_dim]
         
-        self.energy_scale = self.spec_dim[1]
-        
-
         self.model = np.array([])
         self.y_scale = 1.0
         self.change_y_scale = 1.0
@@ -164,72 +157,17 @@ class PeakFitWidget(object):
 
         self.show_regions = False
             
-        with plt.ioff():
-            self.fig = plt.figure()
-        self.fig.canvas.toolbar_position = 'right'
-        self.fig.canvas.toolbar_visible = True
-        #self.set_dataset()
-        self.set_action()
-        self.y_scale = 1.0
-        self.change_y_scale = 1.0
-        self.plot(scale=False)
-        
-        if 'peak_fit' not in self.dataset.metadata:
-            self.dataset.metadata['peak_fit'] = {}
-            if 'edges' in self.dataset.metadata:
-                if 'fit_area' in self.dataset.metadata['edges']:
-                    self.dataset.metadata['peak_fit']['fit_start'] = \
-                        self.dataset.metadata['edges']['fit_area']['fit_start']
-                    self.dataset.metadata['peak_fit']['fit_end'] = self.dataset.metadata['edges']['fit_area']['fit_end']
-                self.dataset.metadata['peak_fit']['peaks'] = {'0': {'position': self.energy_scale[1],
-                                                                    'amplitude': 1000.0, 'width': 1.0,
-                                                                    'type': 'Gauss', 'asymmetry': 0}}
-
-
-        self.peaks = self.dataset.metadata['peak_fit']
-        if 'fit_start' not in self.peaks:
-            self.peaks['fit_start'].value = self.energy_scale[1]
-            self.peaks['fit_end'].value = self.energy_scale[-2]
-
-        if 'peak_model' in self.peaks:
-            self.peak_model = self.peaks['peak_model']
-            self.model = self.peak_model
-            if 'edge_model' in self.peaks:
-                self.model = self.model + self.peaks['edge_model']
-        else:
-            self.model = np.array([])
-            self.peak_model = np.array([])
-        if 'peak_out_list' in self.peaks:
-            self.peak_out_list = self.peaks['peak_out_list']
-        self.set_peak_list()
-
-        # check whether a core loss analysis has been done previously
-        if not hasattr(self, 'core_loss') and 'edges' in self.dataset.metadata:
-            self.core_loss = True
-        else:
-            self.core_loss = False
-
-        self.update()
-
-        self.selector = matplotlib.widgets.SpanSelector(self.fig.gca(), self.line_select_callback,
-                                         direction="horizontal",
-                                         interactive=True,
-                                         props=dict(facecolor='blue', alpha=0.2))
-        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.fig.canvas])
+        self.set_dataset()
                                       
         self.app_layout = ipywidgets.AppLayout(
             left_sidebar=self.sidebar,
-            center=self.panel,
+            center=self.view.panel,
             footer=None,#message_bar,
             pane_heights=[0, 10, 0],
             pane_widths=[4, 10, 0],
         )
         display(self.app_layout)
+        self.set_action()
         
     def line_select_callback(self, x_min, x_max):
             self.start_cursor.value = np.round(x_min,3)
@@ -247,85 +185,90 @@ class PeakFitWidget(object):
             if key.isdigit():
                 self.peak_list.append((f'Peak {int(key) + 1}', int(key)))
         self.peak_list.append(('add peak', -1))
-        self.sidebar[7, 0].options = self.peak_list
-        self.sidebar[7, 0].value = 0
+        #self.sidebar[7, 0].options = self.peak_list
+        #self.sidebar[7, 0].value = 0
 
 
     def plot(self, scale=True):
         
-        ylim = self.fig.gca().get_ylim()
+        self.view.change_y_scale = self.change_y_scale
+        self.view.y_scale = self.y_scale
+        self.energy_scale = self.dataset.energy_loss.values
         
-        ax = self.fig.gca()
-        ax.clear()
-        ax.plot(self.energy_scale, self.datasets[self.key]*self.y_scale, label=self.datasets[self.key].title)
-        ax.set_xlabel(self.datasets[self.key].labels[0])
-        ax.set_ylabel(self.datasets[self.key].data_descriptor)
-        ax.ticklabel_format(style='sci', scilimits=(-2, 3))
-        if scale:
-            ax.set_ylim(np.array(ylim)*self.change_y_scale)
-        self.change_y_scale = 1.0
-        if self.y_scale != 1.:
-                ax.set_ylabel('scattering probability (ppm/eV)')
-        self.selector = matplotlib.widgets.SpanSelector(self.fig.gca(), self.line_select_callback,
-                                         direction="horizontal",
-                                         interactive=True,
-                                         props=dict(facecolor='blue', alpha=0.2))
-       
+        if self.dataset.data_type == sidpy.DataType.SPECTRAL_IMAGE:
+            spectrum = self.dataset.view.get_spectrum()
+        else:
+            spectrum = self.dataset
         if len(self.model) > 1:
-            ax.plot(self.energy_scale, self.model*self.y_scale, label='model')
-            difference_spec  = self.datasets[self.key] - self.model
-            ax.plot(self.energy_scale, difference_spec*self.y_scale, label='difference')
-            # axis.plot(self.energy_scale, (self.datasets[key] - self.model) / np.sqrt(self.datasets[key])*self.y_scale, label='Poisson')
-                
+            additional_spectra = {'model': self.model,
+                                  'difference': spectrum-self.model}   
+        else:
+            additional_spectra = {}
         if 'peaks' in self.peaks:
-            for index, peak in self.peaks['peaks'].items():
-                p = [peak['position'], peak['amplitude'], peak['width']]
-                ax.plot(self.energy_scale, eels_tools.gauss(self.energy_scale, p))
-                
-        ax.legend()
-        
+            if len(self.peaks)>0:
+                for index, peak in self.peaks['peaks'].items(): # ll
+                    p = [peak['position'], peak['amplitude'], peak['width']]
+                    additional_spectra[f'peak {index}']= eels_tools.gauss(self.energy_scale, p)
+        self.view.plot(scale=True, additional_spectra=additional_spectra )
+        self.change_y_scale = 1.
+    
+        self.view.figure.canvas.draw_idle()
       
         
     def set_dataset(self, index=0):    
-        if 'edges' not in self.dataset.metadata or self.dataset.metadata['edges'] == {}:
-            self.dataset.metadata['edges'] = {'0': {}, 'model': {}, 'use_low_loss': False}
-       
-        self.edges = self.dataset.metadata['edges']
-        if '0' not in self.edges:
-            self.edges['0'] = {}
+        self.spec_dim = ft.get_dimensions_by_type('spectral', self.dataset)
+        if len(self.spec_dim) != 1:
+            raise TypeError('We need exactly one SPECTRAL dimension')
+        self.spec_dim = self.spec_dim[0]        
+        self.energy_scale = self.spec_dim[1]
+        
+        self.y_scale = 1.0
+        self.change_y_scale = 1.0
         
-        if 'fit_area' not in self.edges:
-            self.edges['fit_area'] = {}
-        if 'fit_start' not in self.edges['fit_area']:
-            self.sidebar[1,0].value = np.round(self.energy_scale[50], 3)
-            self.edges['fit_area']['fit_start'] = self.sidebar[1,0].value 
+        if 'peak_fit' not in self.dataset.metadata:
+            self.dataset.metadata['peak_fit'] = {}
+            if 'edges' in self.dataset.metadata:
+                if 'fit_area' in self.dataset.metadata['edges']:
+                    self.dataset.metadata['peak_fit']['fit_start'] = self.dataset.metadata['edges']['fit_area']['fit_start']
+                    self.dataset.metadata['peak_fit']['fit_end'] = self.dataset.metadata['edges']['fit_area']['fit_end']
+                self.dataset.metadata['peak_fit']['peaks'] = {'0': {'position': self.energy_scale[1],
+                                                                    'amplitude': 1000.0, 'width': 1.0,
+                                                                    'type': 'Gauss', 'asymmetry': 0}}
+
+        self.peaks = self.dataset.metadata['peak_fit']
+        if 'fit_start' not in self.peaks:
+            self.peaks['fit_start'] = self.energy_scale[1]
+        if 'fit_end' not in self.peaks:
+            self.peaks['fit_end'] = self.energy_scale[-2]
+
+        if 'peak_model' in self.peaks:
+            self.peak_model = self.peaks['peak_model']
+            self.model = self.peak_model
+            if 'edge_model' in self.peaks:
+                self.model = self.model + self.peaks['edge_model']
         else:
-            self.sidebar[1,0].value = np.round(self.edges['fit_area']['fit_start'],3)
-        if 'fit_end' not in self.edges['fit_area']:
-            self.sidebar[2,0].value = np.round(self.energy_scale[-2], 3)
-            self.edges['fit_area']['fit_end'] = self.sidebar[2,0].value 
+            self.model = np.array([])
+            self.peak_model = np.array([])
+        if 'peak_out_list' in self.peaks:
+            self.peak_out_list = self.peaks['peak_out_list']
+        self.set_peak_list()
+
+        # check whether a core loss analysis has been done previously
+        if not hasattr(self, 'core_loss') and 'edges' in self.dataset.metadata:
+            self.core_loss = True
         else:
-            self.sidebar[2,0].value = np.round(self.edges['fit_area']['fit_end'],3)
-        
-        if self.dataset.data_type.name == 'SPECTRAL_IMAGE':
-            if 'SI_bin_x' not in self.dataset.metadata['experiment']:
-                self.dataset.metadata['experiment']['SI_bin_x'] = 1
-                self.dataset.metadata['experiment']['SI_bin_y'] = 1
-
-            bin_x = self.dataset.metadata['experiment']['SI_bin_x']
-            bin_y = self.dataset.metadata['experiment']['SI_bin_y']
-            # self.dataset.view.set_bin([bin_x, bin_y])
+            self.core_loss = False
+
         self.update()
+        if self.dataset.data_type.name =='SPECTRAL_IMAGE':
+            self.view = eels_dialog_utilities.SIPlot(self.dataset)
+        else:
+            self.view = eels_dialog_utilities.SpectrumPlot(self.dataset)    
+        self.y_scale = 1.0
+        self.change_y_scale = 1.0
                 
     def set_fit_area(self, value):
-        """
-        if self.sidebar[1,0].value > self.sidebar[2,0].value:
-            self.sidebar[1,0].value = self.sidebar[2,0].value - 1.0
-        if float(self.sidebar[1,0].value) < self.energy_scale[0]:
-            self.sidebar[1,0].value = self.energy_scale[0]
-        if self.sidebar[2,0].value > self.energy_scale[-1]:
-            self.sidebar[2,0].value = self.energy_scale[-1]
-        """
+       
         self.peaks['fit_start'] = self.sidebar[1, 0].value 
         self.peaks['fit_end'] = self.sidebar[2, 0].value 
         
@@ -369,7 +312,7 @@ class PeakFitWidget(object):
        
     def fit_peaks(self, value = 0):
         """Fit spectrum with peaks given in peaks dictionary"""
-        print('Fitting peaks...')
+        # print('Fitting peaks...')
         p_in = []
         for key, peak in self.peaks['peaks'].items():
             if key.isdigit():
@@ -389,10 +332,10 @@ class PeakFitWidget(object):
         if 'model' in self.dataset.metadata:
             model = self.dataset.metadata['model'][start_channel:end_channel]
         elif self.core_loss:
-            print('Core loss model found. Fitting on top of the model.')
+            # print('Core loss model found. Fitting on top of the model.')
             model = self.dataset.metadata['edges']['model']['spectrum'][start_channel:end_channel]
         else:
-            print('No core loss model found. Fitting to the full spectrum.')
+            # print('No core loss model found. Fitting to the full spectrum.')
             model = np.zeros(end_channel - start_channel)
 
         # if we have a core loss model we will only fit the difference between the model and the data.
@@ -421,87 +364,31 @@ class PeakFitWidget(object):
                                             'type': 'Gauss',
                                             'associated_edge': ''}
 
-        self.find_associated_edges()
+        eels_tools.find_associated_edges(self.dataset)
         self.find_white_lines()
         self.update()
         self.plot()
     
-    def find_associated_edges(self):
-        onsets = []
-        edges = []
-        if 'edges' in self.dataset.metadata:
-            for key, edge in self.dataset.metadata['edges'].items():
-                if key.isdigit():
-                    element = edge['element']
-                    for sym in edge['all_edges']:  # TODO: Could be replaced with exclude
-                        onsets.append(edge['all_edges'][sym]['onset'] + edge['chemical_shift'])
-                        # if 'sym' == edge['symmetry']:
-                        edges.append([key, f"{element}-{sym}", onsets[-1]])
-            for key, peak in self.peaks['peaks'].items():
-                if key.isdigit():
-                    distance = self.energy_scale[-1]
-                    index = -1
-                    for ii, onset in enumerate(onsets):
-                        if onset < peak['position'] < onset+50:
-                            if distance > np.abs(peak['position'] - onset):
-                                distance = np.abs(peak['position'] - onset)  # TODO: check whether absolute is good
-                                distance_onset = peak['position'] - onset
-                                index = ii
-                    if index >= 0:
-                        peak['associated_edge'] = edges[index][1]  # check if more info is necessary
-                        peak['distance_to_onset'] = distance_onset
+   
 
     def find_white_lines(self):
-        if 'edges' in self.dataset.metadata:
-            white_lines = {}
-            for index, peak in self.peaks['peaks'].items():
-                if index.isdigit():
-                    if 'associated_edge' in peak:
-                        if peak['associated_edge'][-2:] in ['L3', 'L2', 'M5', 'M4']:
-                            if peak['distance_to_onset'] < 10:
-                                area = np.sqrt(2 * np.pi) * peak['amplitude'] * np.abs(peak['width']/np.sqrt(2 * np.log(2)))
-                                if peak['associated_edge'] not in white_lines:
-                                    white_lines[peak['associated_edge']] = 0.
-                                if area > 0:
-                                    white_lines[peak['associated_edge']] += area  # TODO: only positive ones?
-            white_line_ratios = {}
-            white_line_sum = {}
-            for sym, area in white_lines.items():
-                if sym[-2:] in ['L2', 'M4', 'M2']:
-                    if area > 0 and f"{sym[:-1]}{int(sym[-1]) + 1}" in white_lines:
-                        if white_lines[f"{sym[:-1]}{int(sym[-1]) + 1}"] > 0:
-                            white_line_ratios[f"{sym}/{sym[-2]}{int(sym[-1]) + 1}"] = area / white_lines[
-                                f"{sym[:-1]}{int(sym[-1]) + 1}"]
-                            white_line_sum[f"{sym}+{sym[-2]}{int(sym[-1]) + 1}"] = (
-                                        area + white_lines[f"{sym[:-1]}{int(sym[-1]) + 1}"])
-
-                            areal_density = 1.
-                            if 'edges' in self.dataset.metadata:
-                                for key, edge in self.dataset.metadata['edges'].items():
-                                    if key.isdigit():
-                                        if edge['element'] == sym.split('-')[0]:
-                                            areal_density = edge['areal_density']
-                                            break
-                            white_line_sum[f"{sym}+{sym[-2]}{int(sym[-1]) + 1}"] /= areal_density
-
-            self.peaks['white_lines'] = white_lines
-            self.peaks['white_line_ratios'] = white_line_ratios
-            self.peaks['white_line_sums'] = white_line_sum
-            self.wl_list = []
-            self.wls_list = []
-            if len(self.peaks['white_line_ratios']) > 0:
-                for key in self.peaks['white_line_ratios']:
+        eels_tools.find_white_lines(self.dataset)
+        self.wl_list = []
+        self.wls_list = []
+        if 'white_line_ratios' in self.dataset.metadata['peak_fit']:
+            if len(self.dataset.metadata['peak_fit']['white_line_ratios']) > 0:
+                for key in self.dataset.metadata['peak_fit']['white_line_ratios']:
                     self.wl_list.append(key)
-                for key in self.peaks['white_line_sums']:
+                for key in self.dataset.metadata['peak_fit']['white_line_sums']:
                     self.wls_list.append(key)
 
                 self.sidebar[14, 0].options = self.wl_list
                 self.sidebar[14, 0].value = self.wl_list[0]
-                self.sidebar[14, 2].value = f"{self.peaks['white_line_ratios'][self.wl_list[0]]:.2f}"
+                self.sidebar[14, 2].value = f"{self.dataset.metadata['peak_fit']['white_line_ratios'][self.wl_list[0]]:.2f}"
                 
                 self.sidebar[15, 0].options = self.wls_list
                 self.sidebar[15, 0].value = self.wls_list[0]
-                self.sidebar[15, 2].value = f"{self.peaks['white_line_sums'][self.wls_list[0]]*1e6:.4f} ppm"
+                self.sidebar[15, 2].value = f"{self.dataset.metadata['peak_fit']['white_line_sums'][self.wls_list[0]]*1e6:.4f} ppm"
 
             else:
                 self.wl_list.append('Ratio')
@@ -514,28 +401,30 @@ class PeakFitWidget(object):
                 self.sidebar[15, 0].options = ['None']
                 self.sidebar[15, 0].value = 'None'
                 self.sidebar[15, 2].value = ' '
+
     def find_peaks(self, value=0):
         number_of_peaks = int(self.sidebar[5, 0].value)
-
-        # is now sorted in smooth function
-        # flat_list = [item for sublist in self.peak_out_list for item in sublist]
-        # new_list = np.reshape(flat_list, [len(flat_list) // 3, 3])
-        # arg_list = np.argsort(np.abs(new_list[:, 1]))
-
+        if number_of_peaks > len(self.peak_out_list):
+            number_of_peaks = len(self.peak_out_list)
+            self.sidebar[5, 0].value = str(len(self.peak_out_list))
         self.peak_list = []
         self.peaks['peaks'] = {}
+        new_number_of_peaks = 0
         for i in range(number_of_peaks):
             self.peak_list.append((f'Peak {i+1}', i))
             p = self.peak_out_list[i]
-            self.peaks['peaks'][str(i)] = {'position': p[0], 'amplitude': p[1], 'width': p[2], 'type': 'Gauss',
+            if p[1]>0:
+                self.peaks['peaks'][str(new_number_of_peaks)] = {'position': p[0], 'amplitude': p[1], 'width': p[2], 'type': 'Gauss',
                                            'asymmetry': 0}
-
+                new_number_of_peaks += 1
+        self.sidebar[5, 0].value = str(new_number_of_peaks)
         self.peak_list.append((f'add peak', -1))
         
         self.sidebar[7, 0].options = self.peak_list
         self.sidebar[7, 0].value = 0
-        self.find_associated_edges()
-        self.find_white_lines()
+
+        #eels_tools.find_associated_edges(self.dataset)
+        #self.find_white_lines()
 
         self.update()
         self.plot()
@@ -560,13 +449,12 @@ class PeakFitWidget(object):
         else:
             self.model = np.zeros(len(spec_dim[1]))
 
-        self.sidebar[5, 0].value =  number_of_peaks
-
         self.dataset.metadata['peak_fit']['edge_model'] = self.model
         self.model = self.model + self.peak_model
         self.dataset.metadata['peak_fit']['peak_model'] = self.peak_model
         self.dataset.metadata['peak_fit']['peak_out_list'] = self.peak_out_list
-
+        
+        self.sidebar[5, 0].value = str(len(self.peak_out_list))
         self.update()
         self.plot()
         
@@ -592,6 +480,7 @@ class PeakFitWidget(object):
             self.model = self.dataset.metadata['peak_fit']['edge_model'] + self.peak_model
         else:
             self.model = np.zeros(self.dataset.shape)
+
     def modify_peak_position(self, value=-1):
         peak_index = self.sidebar[7, 0].value
         self.peaks['peaks'][str(peak_index)]['position'] = self.sidebar[9,0].value
@@ -609,14 +498,24 @@ class PeakFitWidget(object):
         self.peaks['peaks'][str(peak_index)]['width'] = self.sidebar[11,0].value
         self.make_model()
         self.plot()
+
+    def peak_selection(self, change=None):
+        options = list(self.sidebar[7,0].options)
+            
+        if self.sidebar[7, 0].value < 0:
+            options.insert(-1, (f'Peak {len(options)}', len(options)-1))
+            self.sidebar[7, 0].value = 0
+            self.sidebar[7,0].options = options 
+            self.sidebar[7, 0].value = int(len(options)-2)
+            
+        self.update()
     
-        
     def set_action(self):
         self.sidebar[1, 0].observe(self.set_fit_area, names='value')
         self.sidebar[2, 0].observe(self.set_fit_area, names='value')
         
         self.sidebar[4, 2].on_click(self.smooth)
-        self.sidebar[7,0].observe(self.update)
+        self.sidebar[7,0].observe(self.peak_selection)
         self.sidebar[5,2].on_click(self.find_peaks)
         
         self.sidebar[6, 0].on_click(self.fit_peaks)
@@ -868,6 +767,11 @@ if Qt_available:
             We sort the peaks by area under the Gaussians, assuming that small areas mean noise.
 
             """
+            if 'edges' in self.dataset.metadata:
+                if 'model' in  self.dataset.metadata['edges']:
+                    self.dataset.metadata['model'] = self.dataset.metadata['edges']['model']
+            if 'resolution_function' in self.datasets:
+                self.dataset.metadata['model'] = np.array(self.datasets['resolution_function'])
             iterations = int(self.ui.smooth_list.currentIndex())
 
             self.peak_model, self.peak_out_list, number_of_peaks = smooth(self.dataset, iterations, advanced_present)
@@ -916,71 +820,38 @@ if Qt_available:
                             peak['distance_to_onset'] = distance_onset
 
         def find_white_lines(self):
-            if 'edges' in self.dataset.metadata:
-                white_lines = {}
-                for index, peak in self.peaks['peaks'].items():
-                    if index.isdigit():
-                        if 'associated_edge' in peak:
-                            if peak['associated_edge'][-2:] in ['L3', 'L2', 'M5', 'M4']:
-                                if peak['distance_to_onset'] < 10:
-                                    area = np.sqrt(2 * np.pi) * peak['amplitude'] * np.abs(peak['width']/np.sqrt(2 * np.log(2)))
-                                    if peak['associated_edge'] not in white_lines:
-                                        white_lines[peak['associated_edge']] = 0.
-                                    if area > 0:
-                                        white_lines[peak['associated_edge']] += area  # TODO: only positive ones?
-                white_line_ratios = {}
-                white_line_sum = {}
-                for sym, area in white_lines.items():
-                    if sym[-2:] in ['L2', 'M4', 'M2']:
-                        if area > 0 and f"{sym[:-1]}{int(sym[-1]) + 1}" in white_lines:
-                            if white_lines[f"{sym[:-1]}{int(sym[-1]) + 1}"] > 0:
-                                white_line_ratios[f"{sym}/{sym[-2]}{int(sym[-1]) + 1}"] = area / white_lines[
-                                    f"{sym[:-1]}{int(sym[-1]) + 1}"]
-                                white_line_sum[f"{sym}+{sym[-2]}{int(sym[-1]) + 1}"] = (
-                                            area + white_lines[f"{sym[:-1]}{int(sym[-1]) + 1}"])
-
-                                areal_density = 1.
-                                if 'edges' in self.dataset.metadata:
-                                    for key, edge in self.dataset.metadata['edges'].items():
-                                        if key.isdigit():
-                                            if edge['element'] == sym.split('-')[0]:
-                                                areal_density = edge['areal_density']
-                                                break
-                                white_line_sum[f"{sym}+{sym[-2]}{int(sym[-1]) + 1}"] /= areal_density
-
-                self.peaks['white_lines'] = white_lines
-                self.peaks['white_line_ratios'] = white_line_ratios
-                self.peaks['white_line_sums'] = white_line_sum
-                self.ui.wl_list = []
-                self.ui.wls_list = []
-                if len(self.peaks['white_line_ratios']) > 0:
-                    for key in self.peaks['white_line_ratios']:
-                        self.ui.wl_list.append(key)
-                    for key in self.peaks['white_line_sums']:
-                        self.ui.wls_list.append(key)
-
-                    self.ui.listwl.clear()
-                    self.ui.listwl.addItems(self.ui.wl_list)
-                    self.ui.listwl.setCurrentIndex(0)
-                    self.ui.unitswl.setText(f"{self.peaks['white_line_ratios'][self.ui.wl_list[0]]:.2f}")
-
-                    self.ui.listwls.clear()
-                    self.ui.listwls.addItems(self.ui.wls_list)
-                    self.ui.listwls.setCurrentIndex(0)
-                    self.ui.unitswls.setText(f"{self.peaks['white_line_sums'][self.ui.wls_list[0]]*1e6:.4f} ppm")
-                else:
-                    self.ui.wl_list.append('Ratio')
-                    self.ui.wls_list.append('Sum')
+            eels_tools.find_white_lines(self.dataset)
 
-                    self.ui.listwl.clear()
-                    self.ui.listwl.addItems(self.ui.wl_list)
-                    self.ui.listwl.setCurrentIndex(0)
-                    self.ui.unitswl.setText('')
+            self.ui.wl_list = []
+            self.ui.wls_list = []
+            if len(self.peaks['white_line_ratios']) > 0:
+                for key in self.peaks['white_line_ratios']:
+                    self.ui.wl_list.append(key)
+                for key in self.peaks['white_line_sums']:
+                    self.ui.wls_list.append(key)
+
+                self.ui.listwl.clear()
+                self.ui.listwl.addItems(self.ui.wl_list)
+                self.ui.listwl.setCurrentIndex(0)
+                self.ui.unitswl.setText(f"{self.peaks['white_line_ratios'][self.ui.wl_list[0]]:.2f}")
 
-                    self.ui.listwls.clear()
-                    self.ui.listwls.addItems(self.ui.wls_list)
-                    self.ui.listwls.setCurrentIndex(0)
-                    self.ui.unitswls.setText('')
+                self.ui.listwls.clear()
+                self.ui.listwls.addItems(self.ui.wls_list)
+                self.ui.listwls.setCurrentIndex(0)
+                self.ui.unitswls.setText(f"{self.peaks['white_line_sums'][self.ui.wls_list[0]]*1e6:.4f} ppm")
+            else:
+                self.ui.wl_list.append('Ratio')
+                self.ui.wls_list.append('Sum')
+
+                self.ui.listwl.clear()
+                self.ui.listwl.addItems(self.ui.wl_list)
+                self.ui.listwl.setCurrentIndex(0)
+                self.ui.unitswl.setText('')
+
+                self.ui.listwls.clear()
+                self.ui.listwls.addItems(self.ui.wls_list)
+                self.ui.listwls.setCurrentIndex(0)
+                self.ui.unitswls.setText('')
 
         def find_peaks(self):
             number_of_peaks = int(str(self.ui.find_edit.displayText()).strip())
@@ -1154,15 +1025,18 @@ def smooth(dataset, iterations, advanced_present):
     # TODO: add sensitivity to dialog and the two functions below
     peaks = dataset.metadata['peak_fit']
 
-    if advanced_present and iterations > 1:
-        peak_model, peak_out_list = advanced_eels_tools.smooth(dataset, peaks['fit_start'],
-                                                                peaks['fit_end'], iterations=iterations)
-    else:
-        peak_model, peak_out_list = eels_tools.find_peaks(dataset, peaks['fit_start'], peaks['fit_end'])
-        peak_out_list = [peak_out_list]
-
-    flat_list = [item for sublist in peak_out_list for item in sublist]
-    new_list = np.reshape(flat_list, [len(flat_list) // 3, 3])
+    peak_model, peak_out_list = eels_tools.find_peaks(dataset,
+                                                                       peaks['fit_start'],
+                                                                       peaks['fit_end'])
+    # 
+    #cif advanced_present and iterations > 1:
+    # peak_model, peak_out_list = advanced_eels_tools.smooth(dataset, peaks['fit_start'],
+    #                                                             peaks['fit_end'], iterations=iterations)
+    # else:
+    #    peak_model, peak_out_list = eels_tools.find_peaks(dataset, peaks['fit_start'], peaks['fit_end'])
+    #    peak_out_list = [peak_out_list]
+
+    new_list = np.reshape(peak_out_list, [len(peak_out_list) // 3, 3])
     area = np.sqrt(2 * np.pi) * np.abs(new_list[:, 1]) * np.abs(new_list[:, 2] / np.sqrt(2 * np.log(2)))
     arg_list = np.argsort(area)[::-1]
     area = area[arg_list]

pyTEMlib/version.py

@@ -1,6 +1,6 @@
 """
 version
 """
-_version = '0.2023.8.0'
+_version = '0.2024.02.0'
 __version__ = _version
-_time = '2023-08-09 19:58:26'
+_time = '2024-02-08 19:58:26'