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

pyTEMlib/eels_dialog_utilities.py

@@ -12,7 +12,7 @@ try:
 
 except:
     Qt_available = False
-    print('Qt dialogs are not available')
+    # print('Qt dialogs are not available')
 
 import sidpy
 import matplotlib.patches as patches
@@ -233,7 +233,7 @@ if Qt_available:
 
             self.selector = SpanSelector(self.axis, self.line_select_callback,
                                          direction="horizontal",
-                                         span_stays=True,
+                                         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}')
@@ -364,8 +364,10 @@ class RegionSelector(object):
         self.xmin = 0
         self.width = 0
 
-        self.span = SpanSelector(ax, self.on_select1, 'horizontal', useblit=True,
-                                 rectprops=dict(alpha=0.5, facecolor='red'), span_stays=True)
+        self.span = SpanSelector(ax, self.on_select1, 
+                                 direction="horizontal",
+                                 interactive=True,
+                                 props=dict(facecolor='blue', alpha=0.2))
         self.cid = ax.figure.canvas.mpl_connect('key_press_event', self.click)
         self.draw = ax.figure.canvas.mpl_connect('draw_event', self.onresize)
 
@@ -552,6 +554,8 @@ def get_likely_edges(energy_scale):
     return likely_edges
 
 
+
+
 def get_periodic_table_info():
     """Info for periodic table dialog"""
     pt_info = \

pyTEMlib/eels_dlg.py

@@ -15,7 +15,7 @@ try:
     from PyQt5 import QtCore, QtGui, QtWidgets
 except:
     Qt_available = False
-    print('Qt dialogs are not available')
+    # print('Qt dialogs are not available')
 
 if Qt_available:
     class UiDialog(object):
@@ -23,7 +23,7 @@ if Qt_available:
         def __init__(self, dialog):
             dialog.setObjectName('Fit Composition Input')
             dialog.resize(371, 184)
-
+            self.dialog = dialog
             valid_float = QtGui.QDoubleValidator()
             valid_int = QtGui.QIntValidator()
             valid_int.setBottom(0)
@@ -85,9 +85,9 @@ if Qt_available:
             self.separator2.setText("Elements")
             self.layout.addWidget(self.separator2, row, 0, 1, 4)
             ######################################################################
-            row += 1
-            self.auto_id_button = QtWidgets.QPushButton('AUto ID', dialog)
-            self.select_button = QtWidgets.QPushButton('Select', dialog)
+            
+            self.auto_id_button = QtWidgets.QPushButton('Auto ID', dialog)
+            self.select_button = QtWidgets.QPushButton('Manual ID', dialog)
 
             self.layout.addWidget(self.auto_id_button, row, 0)
             self.layout.addWidget(self.select_button, row, 2)
@@ -238,6 +238,7 @@ if Qt_available:
 
             self.do_fit_button = QtWidgets.QPushButton('Fit Composition', dialog)
             self.do_fit_button.setCheckable(True)
+            self.do_fit_button.setDefault(True)
 
             self.layout.addWidget(self.do_all_button, row, 0)
             self.layout.addWidget(self.progress, row, 1)

pyTEMlib/eels_tools.py

@@ -28,11 +28,6 @@ from scipy.ndimage import gaussian_filter
 
 from scipy import constants
 import matplotlib.pyplot as plt
-# import matplotlib.patches as patches
-
-# from matplotlib.widgets import SpanSelector
-# import ipywidgets as widgets
-# from IPython.display import display
 
 import requests
 
@@ -44,6 +39,7 @@ import pickle  # pkg_resources,
 import pyTEMlib.file_tools as ft
 from pyTEMlib.xrpa_x_sections import x_sections
 
+import sidpy
 from sidpy.base.num_utils import get_slope
 
 major_edges = ['K1', 'L3', 'M5', 'N5']
@@ -186,6 +182,7 @@ def fit_peaks(spectrum, energy_scale, pin, start_fit, end_fit, only_positive_int
     # TODO: remove zero_loss_fit_width add absolute
 
     fit_energy = energy_scale[start_fit:end_fit]
+    spectrum = np.array(spectrum)
     fit_spectrum = spectrum[start_fit:end_fit]
 
     pin_flat = [item for sublist in pin for item in sublist]
@@ -922,7 +919,10 @@ def find_peaks(dataset, fit_start, fit_end, sensitivity=2):
         if start_channel < index < end_channel:
             peaks.append(index - start_channel)
 
-    if energy_scale[0] > 0:
+    if 'model' in dataset.metadata:
+        model = dataset.metadata['model'][start_channel:end_channel]
+
+    elif energy_scale[0] > 0:
         if 'edges' not in dataset.metadata:
             return
         if 'model' not in dataset.metadata['edges']:
@@ -936,6 +936,7 @@ def find_peaks(dataset, fit_start, fit_end, sensitivity=2):
 
     difference = np.array(spectrum)[start_channel:end_channel] - model
     fit = np.zeros(len(energy_scale))
+    p_out = []
     if len(peaks) > 0:
         p_in = np.ravel([[energy_scale[i], difference[i], .7] for i in peaks])
         [p_out, _] = scipy.optimize.leastsq(residuals_smooth, p_in, ftol=1e-3, args=(energy_scale,
@@ -1097,11 +1098,26 @@ def fit_model(x, y, pin, number_of_peaks, peak_shape, p_zl, restrict_pos=0, rest
     return p, peak_shape
 
 
-def fix_energy_scale(spec, energy):
-    """Shift energy scale according to zero-loss peak position"""
+def fix_energy_scale(spec, energy=None):    
+    """Shift energy scale according to zero-loss peak position
+    
+    This function assumes that the fzero loss peak is the maximum of the spectrum. 
+    """
+
     # determine start and end fitting region in pixels
-    start = np.searchsorted(energy, -10)
-    end = np.searchsorted(energy, 10)
+    if isinstance(spec, sidpy.Dataset):
+        if energy is None:
+            energy = spec.energy_loss.values
+            spec = np.array(spec)
+           
+    else:
+        if energy is None:
+            return
+        if not isinstance(spec, np.ndarray):
+            return
+        
+    start = np.searchsorted(np.array(energy), -10)
+    end = np.searchsorted(np.array(energy), 10)
     startx = np.argmax(spec[start:end]) + start
 
     end = startx + 3
@@ -1130,6 +1146,31 @@ def fix_energy_scale(spec, energy):
 
     return fwhm, fit_mu
 
+def resolution_function2(dataset, width =0.3):
+    guess = [0.2, 1000, 0.02, 0.2, 1000, 0.2]
+    p0 = np.array(guess)
+
+    start = np.searchsorted(dataset.energy_loss, -width / 2.)
+    end = np.searchsorted(dataset.energy_loss, width / 2.)
+    x = dataset.energy_loss[start:end]
+    y = np.array(dataset)[start:end]
+    def zl2(pp, yy, xx):
+        eerr = (yy - zl_func(pp, xx))  # /np.sqrt(y)
+        return eerr
+    
+    [p_zl, _] = leastsq(zl2, p0, args=(y, x), maxfev=2000)
+
+    z_loss = zl_func(p_zl, dataset.energy_loss)
+    z_loss = dataset.like_data(z_loss)
+    z_loss.title = 'resolution_function'
+    z_loss.metadata['zero_loss_parameter']=p_zl
+    
+    dataset.metadata['low_loss']['zero_loss'] = {'zero_loss_parameter': p_zl,
+                                                 'zero_loss_fit': 'Product2Lorentzians'}
+    zero_loss = dataset.like_array(z_loss)
+    return zero_loss, p_zl
+
+
 
 def resolution_function(energy_scale, spectrum, width, verbose=False):
     """get resolution function (zero-loss peak shape) from low-loss spectrum"""
@@ -1193,26 +1234,69 @@ def resolution_function(energy_scale, spectrum, width, verbose=False):
     return z_loss, p_zl
 
 
-def get_energy_shifts(spectrum_image, energy_scale, zero_loss_fit_width):
-    """get shift of spectrum form zero-loss peak position"""
+def get_energy_shifts(spectrum_image, energy_scale=None, zero_loss_fit_width=0.3):
+    """ get shift of spectrum from zero-loss peak position
+        better to use get resolution_functions 
+    """
+    resolution_functions = get_resolution_functions(spectrum_image, energy_scale=energy_scale, zero_loss_fit_width=zero_loss_fit_width)
+    return resolution_functions.metadata['low_loss']['shifts'], resolution_functions.metadata['low_loss']['widths']
+                                               
+def get_resolution_functions(spectrum_image, energy_scale=None, zero_loss_fit_width=0.3):
+    """get resolution_function and shift of spectra form zero-loss peak position"""
+    if isinstance(spectrum_image, sidpy.Dataset):
+        energy_dimension = spectrum_image.get_dimensions_by_type('spectral')
+        if len(energy_dimension) != 1:
+            raise TypeError('Dataset needs to have exactly one spectral dimension to analyze zero-loss peak') 
+        energy_dimension = spectrum_image.get_dimension_by_number(energy_dimension)[0]
+        energy_scale = energy_dimension.values
+        spatial_dimension = spectrum_image.get_dimensions_by_type('spatial')
+    if len(spatial_dimension) == 0:
+        fwhm, delta_e = fix_energy_scale(spectrum_image)
+        z_loss, p_zl = resolution_function(energy_scale - delta_e, spectrum_image, zero_loss_fit_width)
+        fwhm2, delta_e2 = fix_energy_scale(z_loss, energy_scale - delta_e)
+        return delta_e + delta_e2, fwhm2
+    elif len(spatial_dimension) != 2:
+        return
     shifts = np.zeros(spectrum_image.shape[0:2])
+    widths = np.zeros(spectrum_image.shape[0:2])
+    resolution_functions = spectrum_image.copy()
     for x in range(spectrum_image.shape[0]):
         for y in range(spectrum_image.shape[1]):
-            spectrum = spectrum_image[x, y, :]
+            spectrum = np.array(spectrum_image[x, y])
             fwhm, delta_e = fix_energy_scale(spectrum, energy_scale)
             z_loss, p_zl = resolution_function(energy_scale - delta_e, spectrum, zero_loss_fit_width)
+            resolution_functions[x, y] = z_loss
             fwhm2, delta_e2 = fix_energy_scale(z_loss, energy_scale - delta_e)
             shifts[x, y] = delta_e + delta_e2
-    return shifts
+            widths[x,y] = fwhm2
 
+    resolution_functions.metadata['low_loss'] = {'shifts': shifts,
+                                                 'widths': widths}
+    return resolution_functions
 
-def shift_on_same_scale(spectrum_image, shift, energy_scale, master_energy_scale):
-    """shift spectrum in energy"""
 
-    new_si = np.zeros(spectrum_image.shape)
+def shift_on_same_scale(spectrum_image, shifts=None, energy_scale=None, master_energy_scale=None):
+    """shift spectrum in energy"""
+    if isinstance(spectrum_image, sidpy.Dataset):
+        if shifts is None:
+            if 'low_loss' in spectrum_image.metadata:
+                if 'shifts' in spectrum_image.metadata['low_loss']:
+                    shifts = spectrum_image.metadata['low_loss']['shifts']
+                else:
+                    resolution_functions = get_resolution_functions(spectrum_image)
+                    shifts = resolution_functions.metadata['low_loss']['shifts']
+        energy_dimension = spectrum_image.get_dimensions_by_type('spectral')
+        if len(energy_dimension) != 1:
+            raise TypeError('Dataset needs to have exactly one spectral dimension to analyze zero-loss peak') 
+        energy_dimension = spectrum_image.get_dimension_by_number(energy_dimension)[0]
+        energy_scale = energy_dimension.values
+        master_energy_scale = energy_scale.copy()
+                   
+    new_si = spectrum_image.copy()
+    new_si *= 0.0
     for x in range(spectrum_image.shape[0]):
         for y in range(spectrum_image.shape[1]):
-            tck = interpolate.splrep(energy_scale - shift[x, y], spectrum_image[x, y, :], k=1, s=0)
+            tck = interpolate.splrep(np.array(energy_scale - shifts[x, y]), np.array(spectrum_image[x, y]), k=1, s=0)
             new_si[x, y, :] = interpolate.splev(master_energy_scale, tck, der=0)
     return new_si
 
@@ -1352,6 +1436,8 @@ def xsec_xrpa(energy_scale, e0, z, beta, shift=0):
     enexs = x_sections['ene']
     datxs = x_sections['dat']
 
+    # enexs = enexs[:len(datxs)]
+
     #####
     # Cross Section according to Egerton Ultramicroscopy 50 (1993) 13-28 equation (4)
     #####
@@ -1432,29 +1518,27 @@ def drude_simulation(dset, e, ep, ew, tnm, eb):
     the output is shown in Fig. b.1a,b.
 
     """
+    
     epc = dset.energy_scale[1] - dset.energy_scale[0]  # input('ev per channel : ');
-    e0 = dset.metadata['acceleration_voltage'] / 1000.  # input('incident energy e0(kev) : ');
-    # tnm = input('thickness(nm) : ');
-
-    b = dset.metadata['collection_angle']  # rad
+    
+    b = dset.metadata['collection_angle']/ 1000.  # rad
     epc = dset.energy_scale[1] - dset.energy_scale[0]  # input('ev per channel : ');
     e0 = dset.metadata['acceleration_voltage'] / 1000.  # input('incident energy e0(kev) : ');
 
+    # effective kinetic energy: T = m_o v^2/2,
     t = 1000.0 * e0 * (1. + e0 / 1022.12) / (1.0 + e0 / 511.06) ** 2  # eV # equ.5.2a or Appendix E p 427
+    
+    # 2 gamma T
     tgt = 1000 * e0 * (1022.12 + e0) / (511.06 + e0)  # eV  Appendix E p 427
+    
     rk0 = 2590 * (1.0 + e0 / 511.06) * np.sqrt(2.0 * t / 511060)
+    
     os = e[0]
     ew_mod = eb
     tags = dset.metadata
-    # eps = 1 - ep**2/(e**2-eb**2+2*e*ew*1j)   # eq 3.64
-    # eps = 1 - ep**2/(e**2+2*e*ew*1j)   # eq 3.64
-    # eps = 1 - (ep**2)/(e**2+e*ew*1j-ep**2) # Lorentz Term
+   
     eps = 1 - (ep ** 2 - ew_mod * e * 1j) / (e ** 2 + 2 * e * ew * 1j)  # Mod drude term
-    # eps1 = np.real(eps);
-    # eps2 = np.imag(eps);
-    # eps1 = 1. - ep.^2./(e.^2+ew.^2);  #eq 3.40
-    # eps2 = ew.*ep.^2./e./(e.^2+ew.^2);#eq 3.40
-    # elf = ep**2*e*ew/((e**2-ep**2)**2+(e*ew)**2);    # eq 3.40?
+    
     eps[np.nonzero(eps == 0.0)] = 1e-19
     elf = np.imag(-1 / eps)
 
@@ -1464,16 +1548,16 @@ def drude_simulation(dset, e, ep, ew, tnm, eb):
     angdep = np.arctan(b / the) / the - b / (b * b + the * the)
     srfint = angdep * srfelf / (3.1416 * 0.05292 * rk0 * t)  # probability per eV
     anglog = np.log(1.0 + b * b / the / the)
-    i0 = tags['spec'].sum()  # *tags['counts2e']
-    # print('counts2e',1/tags['counts2e'])
+    i0 = dset.sum()  # *tags['counts2e']
+    
 
     # 2 * t = m_0 v**2 !!!  a_0 = 0.05292 nm
     volint = abs(tnm / (np.pi * 0.05292 * t * 2.0) * elf * anglog)  # S equ 4.26% probability per eV
     volint = volint * i0 / epc  # S probability per channel
     ssd = volint  # + srfint;
 
-    if os < -1.0:
-        xs = int(abs(-os / epc))
+    if e[0] < -1.0:
+        xs = int(abs(-e[0] / epc))
 
         ssd[0:xs] = 0.0
         volint[0:xs] = 0.0
@@ -1486,10 +1570,6 @@ def drude_simulation(dset, e, ep, ew, tnm, eb):
         lam = tnm / p_v  # does NOT depend on free-electron approximation (no damping).
         lamfe = 4.0 * 0.05292 * t / ep / np.log(1 + (b * tgt / ep) ** 2)  # Eq.(3.44) approximation
 
-        # print('p_s(2surfaces+begrenzung terms) =', p_s, 'p_v=t/lambda(beta)= ',p_v,'\n');
-        # print('Volume-plasmon MFP(nm) = ', lam,' Free-electron MFP(nm) = ',lamfe,'\n');
-        # print('--------------------------------\n');
-
         tags['eps'] = eps
         tags['lam'] = lam
         tags['lamfe'] = lamfe

pyTEMlib/file_tools.py

@@ -95,6 +95,8 @@ class FileWidget(object):
         self.dir_list = ['.']
         self.extensions = extension
         self.file_name = ''
+        self.datasets ={}
+        self.dataset = None
 
         self.select_files = widgets.Select(
             options=self.dir_list,
@@ -104,9 +106,56 @@ class FileWidget(object):
             rows=10,
             layout=widgets.Layout(width='70%')
         )
-        display(self.select_files)
+        
+        select_button = widgets.Button(description='Select Main',
+                     layout=widgets.Layout(width='auto', grid_area='header'),
+                     style=widgets.ButtonStyle(button_color='lightblue'))
+        
+        add_button = widgets.Button(description='Add',
+                     layout=widgets.Layout(width='auto', grid_area='header'),
+                     style=widgets.ButtonStyle(button_color='lightblue'))
+        
+        self.path_choice = widgets.Dropdown(options=['None'],
+                                             value='None',
+                                             description='directory:',
+                                             disabled=False,
+                                             button_style='',
+                                             layout=widgets.Layout(width='90%'))
+        self.dataset_list = ['None']
+        self.loaded_datasets = widgets.Dropdown(options=self.dataset_list,
+                                             value=self.dataset_list[0],
+                                             description='loaded datasets:',
+                                             disabled=False,
+                                             button_style='')
+        
         self.set_options()
+        ui = widgets.VBox([self.path_choice, self.select_files, widgets.HBox([select_button, add_button, self.loaded_datasets])])
+        display(ui)
+        
         self.select_files.observe(self.get_file_name, names='value')
+        self.path_choice.observe(self.set_dir, names='value')
+
+        select_button.on_click(self.select_main)
+        add_button.on_click(self.add_dataset)
+        self.loaded_datasets.observe(self.selected_dataset)
+
+    def select_main(self, value=0):
+        self.datasets = {}
+        self.loaded_datasets.value = self.dataset_list[0]
+        self.datasets = open_file(self.file_name)
+        self.dataset_list = []
+        for key in self.datasets.keys():
+            self.dataset_list.append(f'{key}: {self.datasets[key].title}')
+        self.loaded_datasets.options = self.dataset_list
+        self.loaded_datasets.value = self.dataset_list[0]
+        self.dataset = self.datasets[list(self.datasets.keys())[0]]
+        self.selected_dataset = self.dataset
+        
+    def add_dataset(self, value=0):
+        key = add_dataset_from_file(self.datasets, self.file_name, 'Channel')
+        self.dataset_list.append(f'{key}: {self.datasets[key].title}')
+        self.loaded_datasets.options = self.dataset_list
+        self.loaded_datasets.value = self.dataset_list[-1]
 
     def get_directory(self, directory=None):
         self.dir_name = directory
@@ -114,6 +163,17 @@ class FileWidget(object):
         self.dir_list = []
         self.dir_list = ['.', '..'] + os.listdir(directory)
 
+    def set_dir(self, value=0):
+        self.dir_name = self.path_choice.value
+        self.select_files.index = 0
+        self.set_options()
+
+    def selected_dataset(self, value=0):
+        
+        key = self.loaded_datasets.value.split(':')[0]
+        if key != 'None':
+            self.selected_dataset = self.datasets[key]
+
     def set_options(self):
         self.dir_name = os.path.abspath(os.path.join(self.dir_name, self.dir_list[self.select_files.index]))
         dir_list = os.listdir(self.dir_name)
@@ -137,6 +197,16 @@ class FileWidget(object):
 
         self.dir_label = os.path.split(self.dir_name)[-1] + ':'
         self.select_files.options = self.display_list
+        
+        path = self.dir_name
+        old_path = ' '
+        path_list = []
+        while path != old_path:
+            path_list.append(path)
+            old_path = path
+            path = os.path.split(path)[0]
+        self.path_choice.options = path_list
+        self.path_choice.value = path_list[0]
 
     def get_file_name(self, b):
 
@@ -589,7 +659,7 @@ def open_file(filename=None,  h5_group=None, write_hdf_file=False):  # save_file
 
         # tags = open_file(filename)
         if extension in ['.dm3', '.dm4']:
-            reader = SciFiReaders.DM3Reader(filename)
+            reader = SciFiReaders.DMReader(filename)
 
         elif extension in ['.emi']:
             try:
@@ -875,7 +945,7 @@ def log_results(h5_group, dataset=None, attributes=None):
     return log_group
 
 
-def add_dataset_from_file(datasets, filename=None, keyname='Log'):
+def add_dataset_from_file(datasets, filename=None, key_name='Log', single_dataset=True):
     """Add dataset to datasets dictionary
 
     Parameters
@@ -884,23 +954,35 @@ def add_dataset_from_file(datasets, filename=None, keyname='Log'):
         dictionary to write to file
     filename: str, default: None, 
         name of file to open, if None, adialog will appear
-    keyname: str, default: 'Log'
+    key_name: str, default: 'Log'
         name for key in dictionary with running number being added
 
-
     Returns
     -------
-        nothing
+    key_name: str
+        actual last used name of dictionary key
     """
 
     datasets2 =  open_file(filename=filename)
-    index = 0
-    for key in datasets.keys():
-        if keyname in key:
-            if int(key[-3:]) >= index:
-                index = int(key[-3:])+1
-    for dataset in datasets2.values():
-        datasets[keyname+f'_{index:03}'] =  dataset
+    first_dataset = datasets2[list(datasets2)[0]]
+    if isinstance(first_dataset, sidpy.Dataset):
+            
+        index = 0
+        for key in datasets.keys():
+            if key_name in key:
+                if int(key[-3:]) >= index:
+                    index = int(key[-3:])+1
+        if single_dataset:
+            datasets[key_name+f'_{index:03}'] =  first_dataset
+        else:
+            for dataset in datasets2.values():
+                datasets[key_name+f'_{index:03}'] =  dataset
+                index += 1
+            index -= 1
+    else:
+        return None       
+
+    return f'{key_name}_{index:03}'
 
 
 # ##