pyTEMlib 0.2024.9.0__py3-none-any.whl → 0.2025.2.2__py3-none-any.whl

pyTEMlib/peak_dialog.py

@@ -136,13 +136,13 @@ def get_sidebar():
     return side_bar
 
 class PeakFitWidget(object):
-    def __init__(self, datasets=None):
+    def __init__(self, datasets, key):
         self.datasets = datasets
         if not isinstance(datasets, dict):
             raise TypeError('need dictioary of sidpy datasets')
             
         self.sidebar = get_sidebar()
-        self.key = list(self.datasets)[0]
+        self.key = key
         self.dataset = datasets[self.key]
         if not isinstance(self.dataset, sidpy.Dataset):
             raise TypeError('dataset or first item inhas to be a sidpy dataset')
@@ -199,16 +199,22 @@ class PeakFitWidget(object):
             spectrum = self.dataset.view.get_spectrum()
         else:
             spectrum = self.dataset
+        #if 'features' in self.peaks:
+        if 'resolution_function' in self.datasets.keys():
+            
+            zl = self.datasets['resolution_function']  # self.peaks['features']]
+        additional_spectra = {}
         if len(self.model) > 1:
             additional_spectra = {'model': self.model,
-                                  'difference': spectrum-self.model}   
+                                  'difference': spectrum-self.model,
+                                  'zero_loss': self.datasets['resolution_function']}   
         else:
             additional_spectra = {}
         if 'peaks' in self.peaks:
             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)
+                    additional_spectra[f'peak {index}']= gauss(np.array(self.energy_scale), p)
         self.view.plot(scale=True, additional_spectra=additional_spectra )
         self.change_y_scale = 1.
     
@@ -263,7 +269,9 @@ class PeakFitWidget(object):
         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.view = eels_dialog_utilities.SpectrumPlot(self.dataset)
+        self.dataset.view = self.view
+        #self.view.legend(loc='Upper Right')
         self.y_scale = 1.0
         self.change_y_scale = 1.0
                 
@@ -309,19 +317,26 @@ class PeakFitWidget(object):
             self.peaks['peaks'][str(peak_index)]['asymmetry'] = 0.
         self.sidebar[12, 0].value = self.peaks['peaks'][str(peak_index)]['asymmetry']
 
-       
-    def fit_peaks(self, value = 0):
-        """Fit spectrum with peaks given in peaks dictionary"""
-        # print('Fitting peaks...')
+    
+    def get_input(self):
         p_in = []
         for key, peak in self.peaks['peaks'].items():
             if key.isdigit():
                 p_in.append(peak['position'])
                 p_in.append(peak['amplitude'])
                 p_in.append(peak['width'])
+        return p_in
 
-        spectrum = np.array(self.dataset)
-
+       
+    def fit_peaks(self, value=0):
+        """Fit spectrum with peaks given in peaks dictionary"""
+        # print('Fitting peaks...')
+        
+        if self.dataset.data_type.name == 'SPECTRUM':
+            spectrum = np.array(self.dataset)
+        else:
+            spectrum = self.dataset.view.get_spectrum()
+        spectrum -= spectrum.min() - 1
         # set the energy scale and fit start and end points
         energy_scale = np.array(self.energy_scale)
         start_channel = np.searchsorted(energy_scale, self.peaks['fit_start'])
@@ -335,25 +350,31 @@ class PeakFitWidget(object):
             # 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.')
             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.
         difference = np.array(spectrum[start_channel:end_channel] - model)
-
+        p_in = self.get_input()
         # find the optimum fitting parameters
-        [self.p_out, _] = scipy.optimize.leastsq(eels_tools.residuals_smooth, np.array(p_in), ftol=1e-3,
-                                                    args=(energy_scale, difference, False))
+        #[self.p_out, _] = scipy.optimize.leastsq(eels_tools.residuals_smooth, np.array(p_in), ftol=1e-3,
+        #                                            args=(energy_scale, difference, False))
 
+        [self.p_out, _] = scipy.optimize.leastsq(eels_tools.residuals3, np.array(p_in, dtype=np.float64),
+                                                    args=(energy_scale, difference)  ) # , False))
         # construct the fit data from the optimized parameters
-        self.peak_model = np.zeros(len(self.energy_scale))
-        self.model = np.zeros(len(self.energy_scale))
-        self.model[start_channel:end_channel] = model
-        fit = eels_tools.model_smooth(energy_scale, self.p_out, False)
-        self.peak_model[start_channel:end_channel] = fit
-        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.peak_model = np.zeros(len(self.energy_scale))
+        #self.model = np.zeros(len(self.energy_scale))
+        #self.model[start_channel:end_channel] = model
+        #fit = eels_tools.model_smooth(energy_scale, self.p_out, False)
+        fit = eels_tools.gmm(energy_scale, self.p_out)  # , False)
+        self.peak_model = fit
+        
+        #self.peak_model[start_channel:end_channel] = fit
+        #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
 
         for key, peak in self.peaks['peaks'].items():
             if key.isdigit():
@@ -410,13 +431,29 @@ class PeakFitWidget(object):
         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]
-            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
+
+        peaks, prop = scipy.signal.find_peaks(self.peak_model, width=5)
+        print(len(peaks), number_of_peaks, len(peaks)>= number_of_peaks)
+        if len(peaks) >= number_of_peaks:
+            if self.dataset.data_type.name == 'SPECTRUM':
+                spectrum = np.array(self.dataset)
+            else:
+                spectrum = self.dataset.view.get_spectrum()
+            for i in range(number_of_peaks):
+                self.peak_list.append((f'Peak {i+1}', i))
+                p = [self.energy_scale[peaks[i]], np.float32(spectrum[peaks[i]]), np.sqrt(prop['widths'][i])]
+                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
+        else:
+            for i in range(number_of_peaks):
+                self.peak_list.append((f'Peak {i+1}', i))
+                p = self.peak_out_list[i]
+                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))
         
@@ -437,9 +474,13 @@ class PeakFitWidget(object):
         """
         iterations = self.sidebar[4, 0].value
         self.sidebar[5, 0].value =  0
-        advanced_present=False
+        
+        if self.key == self.datasets['_relationship']['low_loss']:
+           if 'resolution_function' in self.datasets['_relationship'].keys():
+               self.model = np.array(self.datasets['resolution_function'])
+
 
-        self.peak_model, self.peak_out_list, number_of_peaks = smooth(self.dataset, iterations, advanced_present)
+        self.peak_model, self.peak_out_list, number_of_peaks = smooth(self.dataset-self.model, iterations, advanced_present)
 
         spec_dim = ft.get_dimensions_by_type('SPECTRAL', self.dataset)[0]
         if spec_dim[1][0] > 0:
@@ -454,7 +495,9 @@ class PeakFitWidget(object):
         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))
+        peaks, prop = scipy.signal.find_peaks(self.peak_model, width=5)
+
+        self.sidebar[5, 0].value = str(len(peaks))
         self.update()
         self.plot()
         
@@ -471,15 +514,20 @@ class PeakFitWidget(object):
         energy_scale = np.array(self.energy_scale)
         start_channel = np.searchsorted(energy_scale, self.peaks['fit_start'])
         end_channel = np.searchsorted(energy_scale, self.peaks['fit_end'])
-        energy_scale = self.energy_scale[start_channel:end_channel]
+        energy_scale = self.energy_scale # [start_channel:end_channel]
         # select the core loss model if it exists. Otherwise, we will fit to the full spectrum.
-            
-        fit = eels_tools.model_smooth(energy_scale, p_peaks, False)
-        self.peak_model[start_channel:end_channel] = fit
-        if 'edge_model' in self.dataset.metadata['peak_fit']:
+        
+        p_peaks = np.array(p_peaks, dtype=np.float64)
+        
+        fit = eels_tools.gmm(energy_scale, p_peaks)  # , False)
+        self.peak_model = fit
+        #self.peak_model[start_channel:end_channel] = fit
+        """if 'edge_model' in self.dataset.metadata['peak_fit']:
             self.model = self.dataset.metadata['peak_fit']['edge_model'] + self.peak_model
         else:
             self.model = np.zeros(self.dataset.shape)
+        """
+        self.model = fit
 
     def modify_peak_position(self, value=-1):
         peak_index = self.sidebar[7, 0].value
@@ -683,22 +731,24 @@ if Qt_available:
             self.axis.clear()
 
             self.axis.plot(self.energy_scale, spectrum, label='spectrum')
-            if 'zero_loss' in self.dataset.metadata:
-                self.axis.plot(self.energy_scale, spectrum, label=name)
+            #if 'features' in self.peaks:
+            zl = self.datasets[self.peaks['features']]
+            self.axis.plot(self.energy_scale, zl, label='zero_loss')
 
             if len(self.model) > 1:
                 self.axis.plot(self.energy_scale, self.model, label='model')
                 self.axis.plot(self.energy_scale, spectrum - self.model, label='difference')
                 #self.axis.plot(self.energy_scale, (spectrum - self.model) / np.sqrt(spectrum), label='Poisson')
-                self.axis.legend()
+            
             self.axis.set_xlim(x_limit)
             self.axis.set_ylim(y_limit)
-            self.axis.figure.canvas.draw_idle()
-
+            
             for index, peak in self.peaks['peaks'].items():
                 p = [peak['position'], peak['amplitude'], peak['width']]
                 self.axis.plot(self.energy_scale, eels_tools.gauss(self.energy_scale, p))
-
+            self.axis.legend(loc="upper right")
+            self.axis.figure.canvas.draw_idle()
+            
         def fit_peaks(self):
             """Fit spectrum with peaks given in peaks dictionary"""
             print('Fitting peaks...')
@@ -714,10 +764,10 @@ if Qt_available:
                 spectrum = self.dataset.view.get_spectrum()
             else:
                 spectrum = np.array(self.dataset)
-
+            spectrum -= spectrum.min()-1
             # set the energy scale and fit start and end points
             energy_scale = np.array(self.energy_scale)
-            start_channel = np.searchsorted(energy_scale, self.peaks['fit_start'])
+            """start_channel = np.searchsorted(energy_scale, self.peaks['fit_start'])
             end_channel = np.searchsorted(energy_scale, self.peaks['fit_end'])
 
             energy_scale = self.energy_scale[start_channel:end_channel]
@@ -732,19 +782,29 @@ if Qt_available:
                 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.
+            
+            
             difference = np.array(spectrum[start_channel:end_channel] - model)
+            """
+            difference = spectrum
+            if self.key == self.datasets['_relationships']['low_loss']:
+                if 'resolution_function' in self.datasets['_relationships'].keys():
+                    difference -= np.array(self.datasets['_relationships']['resolution_function'])
+                    self.peaks['peaks']['features'] = 'resolution_function'
+                    self.model = np.array(self.datasets['_relationships']['resolution_function'])
 
             # find the optimum fitting parameters
-            [self.p_out, _] = scipy.optimize.leastsq(eels_tools.residuals_smooth, np.array(p_in), ftol=1e-3,
+            [self.p_out, _] = scipy.optimize.leastsq(eels_tools.residuals3, np.array(p_in), ftol=1e-3,
                                                      args=(energy_scale, difference, False))
 
             # construct the fit data from the optimized parameters
-            self.peak_model = np.zeros(len(self.energy_scale))
-            self.model = np.zeros(len(self.energy_scale))
-            self.model[start_channel:end_channel] = model
-            fit = eels_tools.model_smooth(energy_scale, self.p_out, False)
-            self.peak_model[start_channel:end_channel] = fit
-            self.dataset.metadata['peak_fit']['edge_model'] = self.model
+            #self.peak_model = np.zeros(len(self.energy_scale))
+            #self.model = np.zeros(len(self.energy_scale))
+            #self.model[start_channel:end_channel] = model
+            fit = eels_tools.gmm(energy_scale, self.p_out, False)
+            self.peak_model = fit
+            #self.peak_model[start_channel:end_channel] = fit
+            #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
 
@@ -773,8 +833,13 @@ if Qt_available:
             if 'resolution_function' in self.datasets:
                 self.dataset.metadata['model'] = np.array(self.datasets['resolution_function'])
             iterations = int(self.ui.smooth_list.currentIndex())
+            
+            if self.key == self.datasets['_relationships']['low_loss']:
+                if 'resolution_function' in self.datasets['_relationships'].keys():
+                    self.model = np.array(self.datasets['_relationships']['resolution_function'])
+
 
-            self.peak_model, self.peak_out_list, number_of_peaks = smooth(self.dataset, iterations, advanced_present)
+            self.peak_model, self.peak_out_list, number_of_peaks = smooth(self.dataset-self.model, iterations, advanced_present)
 
             spec_dim = ft.get_dimensions_by_type('SPECTRAL', self.dataset)[0]
             if spec_dim[1][0] > 0:
@@ -1015,6 +1080,8 @@ if Qt_available:
             
 
 def smooth(dataset, iterations, advanced_present):
+    from pyTEMlib import advanced_eels_tools
+
     """Gaussian mixture model (non-Bayesian)
 
     Fit lots of Gaussian to spectrum and let the program sort it out
@@ -1023,15 +1090,15 @@ def smooth(dataset, iterations, advanced_present):
     """
 
     # TODO: add sensitivity to dialog and the two functions below
-    peaks = dataset.metadata['peak_fit']
+    #peaks = dataset.metadata['peak_fit']
+    
+    #peak_model, peak_out_list = eels_tools.find_peaks(dataset, peaks['fit_start'], peaks['fit_end'])
+    peak_model, peak_out_list = eels_tools.gaussian_mixture_model(dataset, p_in=None)
 
-    peak_model, peak_out_list = eels_tools.find_peaks(dataset,
-                                                                       peaks['fit_start'],
-                                                                       peaks['fit_end'])
     # 
-    #cif advanced_present and iterations > 1:
+    # if advanced_present and iterations > 1:
     # peak_model, peak_out_list = advanced_eels_tools.smooth(dataset, peaks['fit_start'],
-    #                                                             peaks['fit_end'], iterations=iterations)
+    #                                                       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]
@@ -1045,3 +1112,18 @@ def smooth(dataset, iterations, advanced_present):
     number_of_peaks = np.searchsorted(area * -1, -np.average(area))
 
     return peak_model, peak_out_list, number_of_peaks
+
+
+def gauss(x, p):  # p[0]==mean, p[1]= amplitude p[2]==fwhm,
+    """Gaussian Function
+
+        p[0]==mean, p[1]= amplitude p[2]==fwhm
+        area = np.sqrt(2* np.pi)* p[1] * np.abs(p[2] / 2.3548)
+        FWHM = 2 * np.sqrt(2 np.log(2)) * sigma = 2.3548 * sigma
+        sigma = FWHM/3548
+    """
+    if p[2] == 0:
+        return x * 0.
+    else:
+        return p[1] * np.exp(-(x - p[0]) ** 2 / (2.0 * (p[2] / 2.3548) ** 2))
+    

pyTEMlib/probe_tools.py

@@ -2,6 +2,10 @@
 import numpy as np
 import pyTEMlib.image_tools
 import scipy.ndimage as ndimage
+import skimage
+
+get_wavelength = pyTEMlib.image_tools.get_wavelength
+
 
 
 def make_gauss(size_x, size_y, width=1.0, x0=0.0, y0=0.0, intensity=1.0):
@@ -23,6 +27,7 @@ def make_lorentz(size_x, size_y, gamma=1.0, x0=0., y0=0., intensity=1.):
     x, y = np.mgrid[-size_x:size_x, -size_y:size_y]
     g = gamma / (2 * np.pi) / np.power(((x - x0) ** 2 + (y - y0) ** 2 + gamma ** 2), 1.5)
     probe = g / g.sum() * intensity
+    
     return probe
 
 
@@ -32,6 +37,7 @@ def zero_loss_peak_weight():
     y = [0.0143, 0.0193, 0.0281, 0.0440, 0.0768, 0.1447, 0.2785, 0.4955, 0.7442, 0.9380, 1.0000, 0.9483, 0.8596,
          0.7620, 0.6539, 0.5515, 0.4478, 0.3500, 0.2683, 0.1979, 0.1410, 0.1021, 0.0752, 0.0545, 0.0401, 0.0300,
          0.0229, 0.0176, 0.0139]
+    
     return x, y
 
 
@@ -92,6 +98,7 @@ def get_chi(ab, size_x, size_y, verbose=False):
     chi = make_chi(phi, theta, ab)
 
     # Aperture function
+    print(aperture_angle)
     mask = theta >= aperture_angle
 
     aperture = np.ones((size_x, size_y), dtype=float)
@@ -106,15 +113,15 @@ def print_aberrations(ab):
     output += f"Aberrations [nm] for acceleration voltage: {ab['acceleration_voltage'] / 1e3:.0f} kV"
     output += '<table>'
     output += f"<tr><td> C10 </td><td> {ab['C10']:.1f} </tr>"
-    output += f"<tr><td> C12a </td><td> {ab['C12a']:20.1f} <td> C12b </td><td> {ab['C12b']:20.1f} </tr>"
-    output += f"<tr><td> C21a </td><td> {ab['C21a']:.1f} <td> C21b </td><td> {ab['C21b']:.1f} "
-    output += f"    <td> C23a </td><td> {ab['C23a']:.1f} <td> C23b </td><td> {ab['C23b']:.1f} </tr>"
+    output += f"<tr><td> C12a (A1) </td><td> {ab['C12a']:20.1f} <td> C12b (A1) </td><td> {ab['C12b']:20.1f} </tr>"
+    output += f"<tr><td> C21a (B2) </td><td> {ab['C21a']:.1f} <td> C21b (B2)</td><td> {ab['C21b']:.1f} "
+    output += f"    <td> C23a (A2) </td><td> {ab['C23a']:.1f} <td> C23b (A2) </td><td> {ab['C23b']:.1f} </tr>"
     output += f"<tr><td> C30 </td><td> {ab['C30']:.1f} </tr>"
-    output += f"<tr><td> C32a </td><td> {ab['C32a']:20.1f} <td> C32b </td><td> {ab['C32b']:20.1f} "
-    output += f"<td> C34a </td><td> {ab['C34a']:20.1f} <td> C34b </td><td> {ab['C34b']:20.1f} </tr>"
-    output += f"<tr><td> C41a </td><td> {ab['C41a']:.3g} <td> C41b </td><td> {ab['C41b']:.3g} "
-    output += f"    <td> C43a </td><td> {ab['C43a']:.3g} <td> C43b </td><td> {ab['C41b']:.3g} "
-    output += f"    <td> C45a </td><td> {ab['C45a']:.3g} <td> C45b </td><td> {ab['C45b']:.3g} </tr>"
+    output += f"<tr><td> C32a (S3) </td><td> {ab['C32a']:20.1f} <td> C32b (S3)</td><td> {ab['C32b']:20.1f} "
+    output += f"<td> C34a (A3) </td><td> {ab['C34a']:20.1f} <td> C34b (A3) </td><td> {ab['C34b']:20.1f} </tr>"
+    output += f"<tr><td> C41a (B4) </td><td> {ab['C41a']:.3g} <td> C41b (B4) </td><td> {ab['C41b']:.3g} "
+    output += f"    <td> C43a (D4) </td><td> {ab['C43a']:.3g} <td> C43b (D4) </td><td> {ab['C41b']:.3g} "
+    output += f"    <td> C45a (A4) </td><td> {ab['C45a']:.3g} <td> C45b (A4)</td><td> {ab['C45b']:.3g} </tr>"
     output += f"<tr><td> C50 </td><td> {ab['C50']:.3g} </tr>"
     output += f"<tr><td> C52a </td><td> {ab['C52a']:20.1f} <td> C52b </td><td> {ab['C52b']:20.1f} "
     output += f"<td> C54a </td><td> {ab['C54a']:20.1f} <td> C54b </td><td> {ab['C54b']:20.1f} "
@@ -158,11 +165,44 @@ def get_ronchigram(size, ab, scale='mrad'):
         extent = [-fov_mrad, fov_mrad, -fov_mrad, fov_mrad]
         ylabel = 'reciprocal distance [mrad]'
 
+    ab['chi'] = chi
     ab['ronchi_extent'] = extent
     ab['ronchi_label'] = ylabel
     return ronchigram
 
 
+def make_probe (chi, aperture):
+    chi2 = np.fft.ifftshift(chi)
+    chiT = np.fft.ifftshift (np.vectorize(complex)(np.cos(chi2), -np.sin(chi2)) )
+    ## Aply aperture function
+    chiT = chiT*aperture
+    ## inverse fft of aberration function
+    i2  = np.fft.fftshift(np.fft.ifft2(np.fft.ifftshift (chiT)))
+    ## intensity
+    probe = np.real(i2 * np.conjugate(i2))
+
+    return probe
+
+
+def get_probe( ab, sizeX, sizeY,  scale = 'mrad', verbose= True):
+    
+    chi, A_k  = get_chi( ab, sizeX, sizeY, verbose= False)
+    probe = make_probe (chi, A_k)
+
+    return probe, A_k, chi
+
+
+def get_probe_large(ab):    
+    ab['FOV'] = 20
+    sizeX = 512*2
+    probe, A_k, chi  = pyTEMlib.probe_tools.get_probe( ab, sizeX, sizeX,  scale = 'mrad', verbose= True)
+    
+    res = np.zeros((512, 512))
+    res[256-32:256+32, 256-32:256+32 ] = skimage.transform.resize(probe, (64, 64))
+    
+    return res
+
+
 def get_chi_2(ab, u, v):
     chi1 = ab['C10'] * (u ** 2 + v ** 2) / 2 \
            + ab['C12a'] * (u ** 2 - v ** 2) / 2 \
@@ -400,6 +440,22 @@ def get_target_aberrations(TEM_name, acceleration_voltage):
         ab['TEM_name'] = TEM_name
 
         ab['wavelength'] = pyTEMlib.image_tools.get_wavelength(ab['acceleration_voltage'])
+
+    if TEM_name == 'Spectra300':
+        ab = {'C10': 0, 'C12a': 0, 'C12b': 0.38448128113770325, 
+              'C21a': -68.45251255685642, 'C21b': 64.85359774641199, 'C23a': 11.667578600494137, 'C23b': -29.775627778458194, 
+              'C30': 123,
+              'C32a': 95.3047364258614, 'C32b': -189.72105710231244, 'C34a': -47.45099594807912, 'C34b': -94.67424667529909,
+              'C41a': -905.31842572806, 'C41b': 981.316128853203, 'C43a': 4021.8433526960034, 'C43b': 131.72716642732158, 
+              'C45a': -4702.390968272048,  'C45b': -208.25028574642903, 'C50': -663.1, 
+              'C50': 552000., 'C52a': -0., 'C52b': 0.,
+              'C54a': -0., 'C54b': -0., 'C56a': -36663.643489934424, 'C56b': 21356.079837905396,
+              'acceleration_voltage': 200000,
+              'FOV': 34.241659495148205,
+              'Cc': 1* 1e6,
+              'convergence_angle': 30,
+              'wavelength': 0.0025079340450548005}
+ 
     return ab
 
 
@@ -456,6 +512,7 @@ def get_ronchigram_2(size, ab, scale='mrad', threshold=3):
         extent = [-fov_mrad, fov_mrad, -fov_mrad, fov_mrad]
         ylabel = 'reciprocal distance [mrad]'
 
+    ab['chi'] = chi
     ab['ronchi_extent'] = extent
     ab['ronchi_label'] = ylabel
 

pyTEMlib/version.py

@@ -1,6 +1,6 @@
 """
 version
 """
-_version = '0.2024.09.0'
+_version = '0.2025.02.2'
 __version__ = _version
-_time = '2024-09-01 19:58:26'
+_time = '2025-02-25 19:58:26'

{pyTEMlib-0.2024.9.0.dist-info → pytemlib-0.2025.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: pyTEMlib
-Version: 0.2024.9.0
+Version: 0.2025.2.2
 Summary: pyTEM: TEM Data Quantification library through a model-based approach
 Home-page: https://pycroscopy.github.io/pyTEMlib/about.html
 Author: Gerd Duscher
@@ -38,9 +38,19 @@ Requires-Dist: ipympl
 Requires-Dist: spglib
 Requires-Dist: scikit-image
 Requires-Dist: scikit-learn
-Requires-Dist: pyNSID >=0.0.7
-Requires-Dist: sidpy >=0.12.1
-Requires-Dist: SciFiReaders >=0.0.8
+Requires-Dist: pyNSID>=0.0.7
+Requires-Dist: sidpy>=0.12.1
+Requires-Dist: SciFiReaders>=0.0.8
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: platform
+Dynamic: requires-dist
+Dynamic: summary
 
 pyTEMlib
 ========

{pyTEMlib-0.2024.9.0.dist-info → pytemlib-0.2025.2.2.dist-info}/RECORD

@@ -1,37 +1,38 @@
 pyTEMlib/__init__.py,sha256=nEN93amIEoZxO7rJgN71ABeCoXrnmaywBbE97l5lPio,178
-pyTEMlib/animation.py,sha256=oPxbTuy8LfdH2mOOgm9Q40ArFAJmXM_58UV97ptcNAY,25187
-pyTEMlib/atom_tools.py,sha256=ViO4ZZZoCZ_Cp2KijiqKKOiQhGOWnye45T0rsiPhf4I,7314
+pyTEMlib/animation.py,sha256=G9ykYo6yB5jexjKienShO9C2b8xEXKbf7t47apwcwTw,25188
+pyTEMlib/atom_tools.py,sha256=uoyZOs0lZKyBwGH6onKSAKzA6IxseqHpgw7ZTos9Nd0,7335
 pyTEMlib/config_dir.py,sha256=4evlo9P2Yht-AnqaLI-WweLjDQcislbAP3I7P7EZsPU,2085
-pyTEMlib/core_loss_widget.py,sha256=BPGGNcYkdiX3pIfe600ERVAJjUHw5C2BA7idroP1pgU,29746
+pyTEMlib/core_loss_widget.py,sha256=EbCn2imCjzeLAL2h9n87APHPou1G4vvN-kA4_RQs_OE,30991
 pyTEMlib/crystal_tools.py,sha256=g4OXyvd5NLw7vaXhjDP3P6VZpVV6eiyuPn8MdgR2amI,61652
 pyTEMlib/diffraction_plot.py,sha256=pM5d3bdBGa8LlPZ5lw8sLT94mlYTXELxPLv-jUP2FWY,27959
 pyTEMlib/dynamic_scattering.py,sha256=O9MxnxfndWJ2VhQRjksKNQ4yY7y-gN_hitRQ4Qox4ns,9472
 pyTEMlib/eds_tools.py,sha256=Ilof2Cars-1ILXx5g2RsU2G4BgrPwjOHgQ7-OabmbrU,28000
-pyTEMlib/eels_dialog.py,sha256=oWLivCQ96Fq0tj52wbfs-5qKccUSWk2k1iP2TVneXZA,32379
+pyTEMlib/eels_dialog.py,sha256=NmPjO1SVjxzah2cCEK0bR1AqwX7Dl6xwejTZkruqIUA,32619
 pyTEMlib/eels_dialog_utilities.py,sha256=73W9jFbPx-eeLEiSaBptTgGLr40bIYYfSyzLnZbhfvo,51761
-pyTEMlib/eels_tools.py,sha256=O22WENQ04fCfVvI4ktJdx6GfE8ZSNb-E6dAu4ZbfHqw,76041
-pyTEMlib/file_tools.py,sha256=UScJenVk73MZUW-laoKymnO27eCUC0vlRxxlQ4Kq2Hg,46923
+pyTEMlib/eels_tools.py,sha256=7gfDmu-CqfatVmtCPYwObJZsP5RMDx3bmFXclZzJINE,88739
+pyTEMlib/file_tools.py,sha256=gdP42-99Pjnl0tri50x8QXc33ye-1bs6Yiof3JKVn7I,59969
 pyTEMlib/file_tools_qt.py,sha256=tLZACS4JyGH_AOzNR_SGAhjA01y4VJB261opPhGMlm8,7223
 pyTEMlib/graph_tools.py,sha256=iu0Y2hIPU6CkQHQEh-dI1vKnUHnSNXx4-CXs2M-1Sr8,44097
 pyTEMlib/graph_viz.py,sha256=m5PwSn6l2r0bsaLWBDSHc9IGR3_PneG2BrZgnEdi07I,13644
 pyTEMlib/image_dialog.py,sha256=F-ZgKq7UnMtPPd1b9eqb7t8MXDfWN-8hVKwB2Il0x28,6235
 pyTEMlib/image_dlg.py,sha256=n5gradDiYOFGEQ3k_Wlk9RUYYzl4bl_hKLzNVcYteNE,5694
-pyTEMlib/image_tools.py,sha256=B1fLX7PGLrglGuMSavJ5areol8UabyjVUVtkRxYc-oM,49279
-pyTEMlib/info_widget.py,sha256=wd1F6UDcLMsWEg1DHHVPa1P7_MRGv8iLOUjRsYkZOQY,46453
+pyTEMlib/image_tools.py,sha256=guHd29VLo2z0KXz1-XxcHYWqOiHGoKZ0A9SE_FdSO2g,52655
+pyTEMlib/info_widget.py,sha256=lkzQOuNVlkaasiZDtc5UtYk541-plYNfnW4DQwQB_iA,53467
+pyTEMlib/info_widget3.py,sha256=QSbdSj6m57KQTir2fNhulVgjOu9EQL31c-9SzTlghnE,55495
 pyTEMlib/interactive_image.py,sha256=5PwypcA1OjLAD-fi8bmWWFHuOjdIPVY9Dh59V24WuDA,34
 pyTEMlib/kinematic_scattering.py,sha256=CUdJnclkok7d8qm_jDUF92MVHrmaTeMkKdvxxB6AqvA,43309
-pyTEMlib/low_loss_widget.py,sha256=nSU6-pu7gP8ch61w2wpImNNIuo_3bBN1HAB3UVlEJoQ,9043
+pyTEMlib/low_loss_widget.py,sha256=0SxHOAuUnuNjDrJSNS2PeWD6hjyuB5FCYxmVfsDTq5c,25573
 pyTEMlib/microscope.py,sha256=iigUF1UImHEfmL2wqEBBj3aNRgEYouDbIln8VCo4_KM,1545
-pyTEMlib/peak_dialog.py,sha256=-HhgmoscfJMme9N495hDzfniYwuhn7iBzsDwZOOhTd4,48260
+pyTEMlib/peak_dialog.py,sha256=r3mhYvECC9niFFItS1oGa96F2nFthsE5kfpA3yVXQaE,51872
 pyTEMlib/peak_dlg.py,sha256=qcjcnhwpGa4jBCeXzwQz9sCyX-tHsLLQ67ToqfKOiQY,11550
-pyTEMlib/probe_tools.py,sha256=8tPQuANClLsGAKnZo6Vo4gNIGKfyDR6WUMO3dXcm_4k,27177
+pyTEMlib/probe_tools.py,sha256=xVwoThZSSOY6hjUMO53va9R_qI7SL5dfwIigz6sd3DI,29242
 pyTEMlib/sidpy_tools.py,sha256=0oIx-qMtEmcZmLazQKW19dd-KoxyY3B15aIeMcyHA8E,4878
 pyTEMlib/simulation_tools.py,sha256=RmegD5TpQMU68uASvzZWVplAqs7bM5KkF6bWDWLjyc0,2799
-pyTEMlib/version.py,sha256=fwR9D7D8-iWk_APPU-GLy0E-_x3tnurNS454JfAmdHU,94
+pyTEMlib/version.py,sha256=6GC1KyGj1D_9Hs8_3OJrq7lHdhziwk9qllcxLoWcEns,94
 pyTEMlib/xrpa_x_sections.py,sha256=m4gaH7gaJiNi-CsIT9aKoH4fB6MQIAe876kxEmzSebI,1825392
-pyTEMlib-0.2024.9.0.dist-info/LICENSE,sha256=7HdBF6SXIBd38bHOKkQd4DYR1KV-OYm9mwB16fM-984,1062
-pyTEMlib-0.2024.9.0.dist-info/METADATA,sha256=5qc9Ssc7GLKeE5dlv4KErBF7A4_x76dcIM49jJ1aDic,3305
-pyTEMlib-0.2024.9.0.dist-info/WHEEL,sha256=UvcQYKBHoFqaQd6LKyqHw9fxEolWLQnlzP0h_LgJAfI,91
-pyTEMlib-0.2024.9.0.dist-info/entry_points.txt,sha256=zn2yO1IWTutI3c7C9e3GdARCvm43JURoOhqQ8YylV4Y,43
-pyTEMlib-0.2024.9.0.dist-info/top_level.txt,sha256=rPLVH0UJxrPSPgSoKScTjL1K_X69JFzsYYnDnYTYIlU,9
-pyTEMlib-0.2024.9.0.dist-info/RECORD,,
+pytemlib-0.2025.2.2.dist-info/LICENSE,sha256=7HdBF6SXIBd38bHOKkQd4DYR1KV-OYm9mwB16fM-984,1062
+pytemlib-0.2025.2.2.dist-info/METADATA,sha256=tOVUZqAPzyfc6ZXDHRyz5jp6OGzNJvv9CcyE-1bxtxI,3493
+pytemlib-0.2025.2.2.dist-info/WHEEL,sha256=nn6H5-ilmfVryoAQl3ZQ2l8SH5imPWFpm1A5FgEuFV4,91
+pytemlib-0.2025.2.2.dist-info/entry_points.txt,sha256=zn2yO1IWTutI3c7C9e3GdARCvm43JURoOhqQ8YylV4Y,43
+pytemlib-0.2025.2.2.dist-info/top_level.txt,sha256=rPLVH0UJxrPSPgSoKScTjL1K_X69JFzsYYnDnYTYIlU,9
+pytemlib-0.2025.2.2.dist-info/RECORD,,

{pyTEMlib-0.2024.9.0.dist-info → pytemlib-0.2025.2.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (74.0.0)
+Generator: setuptools (75.8.1)
 Root-Is-Purelib: true
 Tag: py3-none-any