pyTEMlib 0.2024.8.4__py3-none-any.whl → 0.2025.2.1__py3-none-any.whl

pyTEMlib/eels_tools.py

@@ -33,6 +33,8 @@ from scipy.signal import peak_prominences
 from scipy.ndimage import gaussian_filter
 from scipy.optimize import curve_fit, leastsq
 
+from numba import jit, float64
+
 import requests
 
 # ## And we use the image tool library of pyTEMlib
@@ -247,7 +249,7 @@ def model_smooth(x, p, only_positive_intensity=False):
 
     return y
 
-
+@jit
 def gauss(x, p):  # p[0]==mean, p[1]= amplitude p[2]==fwhm,
     """Gaussian Function
 
@@ -267,6 +269,8 @@ def lorentz(x, center, amplitude, width):
     lorentz_peak = 0.5 * width / np.pi / ((x - center) ** 2 + (width / 2) ** 2)
     return amplitude * lorentz_peak / lorentz_peak.max()
 
+def zero_loss_function(x, p):
+    return zl_func(x, *p)
 
 def zl_func(x, center1, amplitude1, width1, center2, amplitude2, width2):
     """ zero loss function as product of two lorentzians """
@@ -319,9 +323,9 @@ def get_zero_loss_energy(dataset):
             start = startx - i
         if spectrum[startx + i] < 0.3 * spectrum[startx]:
             end = startx + i
-    if end - start < 3:
-        end = startx + 2
-        start = startx - 2
+    if end - start < 7:
+        end = startx + 4
+        start = startx - 4
     width = int((end-start)/2+0.5)
 
     energy = dataset.get_spectral_dims(return_axis=True)[0].values
@@ -393,6 +397,15 @@ def align_zero_loss(dataset: sidpy.Dataset) -> sidpy.Dataset:
     new_si.metadata.update({'zero_loss': {'shifted': shifts}})
     return new_si
 
+from numba import jit
+
+def get_zero_losses(energy, z_loss_params):
+    z_loss_dset = np.zeros((z_loss_params.shape[0], z_loss_params.shape[1], energy.shape[0]))
+    for x in range(z_loss_params.shape[0]):
+        for y in range(z_loss_params.shape[1]):
+            z_loss_dset[x, y] +=  zl_func(energy, *z_loss_params[x, y])
+    return z_loss_dset
+
 
 
 
@@ -486,11 +499,12 @@ def get_resolution_functions(dataset: sidpy.Dataset, startFitEnergy: float=-1, e
     z_loss_dset = dataset.copy()
     z_loss_dset *= 0.0
 
-    energy_grid = np.broadcast_to(energy.reshape((1, 1, -1)), (z_loss_dset.shape[0],
-                                                               z_loss_dset.shape[1], energy.shape[0]))
-    z_loss_peaks = zl_func(energy_grid, *z_loss_params)
-    z_loss_dset += z_loss_peaks
-
+    #energy_grid = np.broadcast_to(energy.reshape((1, 1, -1)), (z_loss_dset.shape[0],
+    #                                                           z_loss_dset.shape[1], energy.shape[0]))
+    #z_loss_peaks = zl_func(energy_grid, *z_loss_params)
+    z_loss_params = np.array(z_loss_params)
+    z_loss_dset += get_zero_losses(np.array(energy), np.array(z_loss_params))
+    
     shifts = z_loss_params[:, :, 0] * z_loss_params[:, :, 3]
     widths = z_loss_params[:, :, 2] * z_loss_params[:, :, 5]
 
@@ -520,7 +534,15 @@ def drude_lorentz(eps_inf, leng, ep, eb, gamma, e, amplitude):
     return eps
 
 
-def fit_plasmon(dataset: Union[sidpy.Dataset, np.ndarray], startFitEnergy: float, endFitEnergy: float, plot_result: bool = False, number_workers: int = 4, number_threads: int = 8) -> Union[sidpy.Dataset, np.ndarray]:
+def get_plasmon_losses(energy, params):
+    dset = np.zeros((params.shape[0], params.shape[1], energy.shape[0]))
+    for x in range(params.shape[0]):
+        for y in range(params.shape[1]):
+            dset[x, y] +=  energy_loss_function(energy, params[x, y])
+    return dset
+
+
+def fit_plasmon(dataset: Union[sidpy.Dataset, np.ndarray], startFitEnergy: float, endFitEnergy: float,  number_workers: int = 4, number_threads: int = 8) -> Union[sidpy.Dataset, np.ndarray]:
     """
     Fit plasmon peak positions and widths in a TEM dataset using a Drude model.
 
@@ -557,12 +579,14 @@ def fit_plasmon(dataset: Union[sidpy.Dataset, np.ndarray], startFitEnergy: float
         - If `plot_result` is True, the function plots Ep, Ew, and A as separate subplots.
     """
     # define Drude function for plasmon fitting
+
+    anglog, T, _ = angle_correction(dataset)
     def energy_loss_function(E: np.ndarray, Ep: float, Ew: float, A: float) -> np.ndarray:
-        E = E/E.max()
+
         eps = 1 - Ep**2/(E**2+Ew**2) + 1j * Ew * Ep**2/E/(E**2+Ew**2)
-        elf = (-1/eps).imag
+        elf = (-1/eps).imag  
         return A*elf
-
+    
     # define window for fitting
     energy = dataset.get_spectral_dims(return_axis=True)[0].values
     start_fit_pixel = np.searchsorted(energy, startFitEnergy)
@@ -576,32 +600,218 @@ def fit_plasmon(dataset: Union[sidpy.Dataset, np.ndarray], startFitEnergy: float
         dataset = dataset.rechunk(chunks=(1, -1))
         fit_dset = dataset[:, start_fit_pixel:end_fit_pixel]
     else:
-        fit_dset = np.array(dataset[start_fit_pixel:end_fit_pixel])
+        fit_dset = np.array(dataset[start_fit_pixel:end_fit_pixel]/ anglog[start_fit_pixel:end_fit_pixel])
         guess_pos = np.argmax(fit_dset)
         guess_amplitude = fit_dset[guess_pos]
-        guess_width = (endFitEnergy - startFitEnergy)/2
-        popt, pcov = curve_fit(energy_loss_function, energy, dataset,
-                               p0=[guess_pos, guess_width, guess_amplitude])
-        return popt
+        guess_width =(endFitEnergy-startFitEnergy)/4
+        guess_pos = energy[guess_pos]
+        if guess_width >8:
+            guess_width=8
+        try:
+            popt, pcov = curve_fit(energy_loss_function, energy[start_fit_pixel:end_fit_pixel], fit_dset,
+                                p0=[guess_pos, guess_width, guess_amplitude])
+        except:
+            end_fit_pixel = np.searchsorted(energy, 30)
+            fit_dset = np.array(dataset[start_fit_pixel:end_fit_pixel]/ anglog[start_fit_pixel:end_fit_pixel])
+            try:
+                popt, pcov = curve_fit(energy_loss_function, energy[start_fit_pixel:end_fit_pixel], fit_dset,
+                                p0=[guess_pos, guess_width, guess_amplitude])
+            except:
+                popt=[0,0,0]
+       
+        plasmon = dataset.like_data(energy_loss_function(energy, popt[0], popt[1], popt[2]))
+        plasmon *= anglog
+        start_plasmon = np.searchsorted(energy, 0)+1
+        plasmon[:start_plasmon] = 0.
+        
+        epsilon = drude(energy, popt[0], popt[1], 1) * popt[2]
+        epsilon[:start_plasmon] = 0.
+        
+        plasmon.metadata['plasmon'] = {'parameter': popt, 'epsilon':epsilon}
+        return plasmon
     
     # if it can be parallelized:
     fitter = SidFitter(fit_dset, energy_loss_function, num_workers=number_workers,
                        threads=number_threads, return_cov=False, return_fit=False, return_std=False,
                        km_guess=False, num_fit_parms=3)
-    [fitted_dataset] = fitter.do_fit()
+    [fit_parameter] = fitter.do_fit()
+
+    plasmon_dset = dataset * 0.0
+    fit_parameter = np.array(fit_parameter)
+    plasmon_dset += get_plasmon_losses(np.array(energy), fit_parameter)
+    if 'plasmon' not in plasmon_dset.metadata:
+        plasmon_dset.metadata['plasmon'] = {}
+    plasmon_dset.metadata['plasmon'].update({'startFitEnergy': startFitEnergy,
+                                              'endFitEnergy': endFitEnergy,
+                                              'fit_parameter': fit_parameter,
+                                              'original_low_loss': dataset.title})
+
+    return plasmon_dset
+
+
+def angle_correction(spectrum):
+
+    acceleration_voltage = spectrum.metadata['experiment']['acceleration_voltage']
+    energy_scale = spectrum.get_spectral_dims(return_axis=True)[0].values
+    # eff_beta = effective_collection_angle(energy_scale, spectrum.metadata['experiment']['convergence_angle'],
+    #                                     spectrum.metadata['experiment']['collection_angle'],acceleration_voltage)
+   
+    
+    epc = energy_scale[1] - energy_scale[0]  # input('ev per channel : ');
+
+    alpha = spectrum.metadata['experiment']['convergence_angle']  # input('Alpha (mrad) : ');
+    beta = spectrum.metadata['experiment']['collection_angle']# input('Beta (mrad) : ');
+    e = energy_scale
+    e0 = acceleration_voltage/1000 # input('E0 (keV) : ');
+
+    T = 1000.0*e0*(1.+e0/1022.12)/(1.0+e0/511.06)**2  # %eV # equ.5.2a or Appendix E p 427 
+    
+    tgt=e0*(1.+e0/1022.)/(1+e0/511.);
+    thetae=(e+1e-6)/tgt; # % avoid NaN for e=0
+    # %     A2,B2,T2 ARE SQUARES OF ANGLES IN RADIANS**2
+    a2=alpha*alpha*1e-6 + 1e-7;  # % avoid inf for alpha=0
+    b2=beta*beta*1e-6;
+    t2=thetae*thetae*1e-6;
+    eta1=np.sqrt((a2+b2+t2)**2-4*a2*b2)-a2-b2-t2;
+    eta2=2.*b2*np.log(0.5/t2*(np.sqrt((a2+t2-b2)**2+4.*b2*t2)+a2+t2-b2));
+    eta3=2.*a2*np.log(0.5/t2*(np.sqrt((b2+t2-a2)**2+4.*a2*t2)+b2+t2-a2));
+    eta=(eta1+eta2+eta3)/a2/np.log(4./t2);
+    f1=(eta1+eta2+eta3)/2./a2/np.log(1.+b2/t2);
+    f2=f1;
+    if(alpha/beta>1):
+        f2=f1*a2/b2;
+
+    bstar=thetae*np.sqrt(np.exp(f2*np.log(1.+b2/t2))-1.);
+    anglog = f2
+    """
+    b = eff_beta/1000.0 # %rad
+    e0 = acceleration_voltage/1000.0 # %keV
+    T = 1000.0*e0*(1.+e0/1022.12)/(1.0+e0/511.06)**2  # %eV # equ.5.2a or Appendix E p 427 
+    tgt = 1000*e0*(1022.12 + e0)/(511.06 + e0)  # %eV  Appendix E p 427 
+
+    the = energy_scale/tgt # varies with energy loss! # Appendix E p 427 
+    anglog = np.log(1.0+ b*b/the/the)
+    # 2 * T = m_0 v**2 !!!  a_0 = 0.05292 nm  epc is for sum over I0
+    """
+    return anglog,   (np.pi*0.05292* T / 2.0)/epc, bstar[0],
+
+def energy_loss_function(energy_scale: np.ndarray, p: np.ndarray, anglog=1) -> np.ndarray:
+    eps = 1 - p[0]**2/(energy_scale**2+p[1]**2) + 1j * p[1] * p[0]**2/energy_scale/(energy_scale**2+p[1]**2)
+    elf = (-1/eps).imag
+    return elf*p[2]*anglog
+
+def inelatic_mean_free_path(E_p, spectrum):
+    acceleration_voltage = spectrum.metadata['experiment']['acceleration_voltage']
+    energy_scale = spectrum.get_spectral_dims(return_axis=True)[0].values
+    
+    e0 = acceleration_voltage/1000.0 # %keV
+
+    eff_beta = effective_collection_angle(energy_scale, spectrum.metadata['experiment']['convergence_angle'],
+                                         spectrum.metadata['experiment']['collection_angle'],acceleration_voltage)
+    beta = eff_beta/1000.0 # %rad
+    
+    T = 1000.0*e0*(1.+e0/1022.12)/(1.0+e0/511.06)**2  # %eV # equ.5.2a or Appendix E p 427 
+    tgt = 1000*e0*(1022.12 + e0)/(511.06 + e0)  # %eV  Appendix E p 427 
+    theta_e = E_p/tgt # varies with energy loss! # Appendix E p 427
+    
+    # 2 * T = m_0 v**2 !!!  
+    a_0 = 0.05292 # nm 
+    imfp = 4*T*a_0/E_p/np.log(1+beta**2/theta_e**2)
+
+    return imfp, theta_e
+
+
+def multiple_scattering(energy_scale: np.ndarray, p: list, core_loss=False)-> np.ndarray:
+    p = np.abs(p)
+    tmfp = p[3]
+    if core_loss:
+        dif = 1
+    else:
+        dif = 16
+    LLene = np.linspace(1, 2048-1,2048)/dif
+    
+    SSD = energy_loss_function(LLene, p)
+    ssd  = np.fft.fft(SSD)
+    ssd2 = ssd.copy()
+    
+    ### sum contribution from each order of scattering:
+    PSD = np.zeros(len(LLene))
+    for order in range(15):
+        # This order convoluted spectum 
+        # convoluted SSD is SSD2
+        SSD2 = np.fft.ifft(ssd).real
+    
+        # scale right (could be done better? GERD) 
+        # And add this order to final spectrum
+        PSD += SSD2*abs(sum(SSD)/sum(SSD2)) / scipy.special.factorial(order+1)*np.power(tmfp, (order+1))*np.exp(-tmfp) #using equation 4.1 of egerton ed2
+        
+        # next order convolution
+        ssd = ssd * ssd2
+    
+    PSD /=tmfp*np.exp(-tmfp)
+    BGDcoef = scipy.interpolate.splrep(LLene, PSD, s=0)   
+    msd = scipy.interpolate.splev(energy_scale, BGDcoef)
+    start_plasmon = np.searchsorted(energy_scale, 0)+1
+    msd[:start_plasmon] = 0. 
+    return msd
+
+def fit_multiple_scattering(dataset: Union[sidpy.Dataset, np.ndarray], startFitEnergy: float, endFitEnergy: float,pin=None, number_workers: int = 4, number_threads: int = 8) -> Union[sidpy.Dataset, np.ndarray]:
+    """
+    Fit multiple scattering of plasmon peak in a TEM dataset.
+
+    
+    Parameters:
+        dataset: sidpy.Dataset or numpy.ndarray
+            The dataset containing TEM spectral data.
+        startFitEnergy: float
+            The start energy of the fitting window.
+        endFitEnergy: float
+            The end energy of the fitting window.
+        number_workers: int, optional
+            The number of workers for parallel processing (default is 4).
+        number_threads: int, optional
+            The number of threads for parallel processing (default is 8).
+
+    Returns:
+        fitted_dataset: sidpy.Dataset or numpy.ndarray
+            The dataset with fitted plasmon peak parameters. The dimensions and 
+            format depend on the input dataset.
+
+    Raises:
+        ValueError: If the input dataset does not have the expected dimensions or format.
+
+    Notes:
+        - The function uses the Drude model to fit plasmon peaks.
+        - The fitting parameters are peak position (Ep), peak width (Ew), and amplitude (A).
+        - If `plot_result` is True, the function plots Ep, Ew, and A as separate subplots.
+    """
+    
+
+    # define window for fitting
+    energy = dataset.get_spectral_dims(return_axis=True)[0].values
+    start_fit_pixel = np.searchsorted(energy, startFitEnergy)
+    end_fit_pixel = np.searchsorted(energy, endFitEnergy)
+
+    def errf_multi(p, y, x):
+        elf = multiple_scattering(x, p)
+        err = y - elf
+        #print (p,sum(np.abs(err)))
+        return np.abs(err) # /np.sqrt(y)
+
+    if pin is None:
+        pin = np.array([9,1,.7, 0.3])
 
-    if plot_result:
-        fig, (ax1, ax2, ax3) = plt.subplots(1, 3, sharex=True, sharey=True)
-        ax1.imshow(fitted_dataset[:, :, 0], cmap='jet')
-        ax1.set_title('Ep - Peak Position')
-        ax2.imshow(fitted_dataset[:, :, 1], cmap='jet')
-        ax2.set_title('Ew - Peak Width')
-        ax3.imshow(fitted_dataset[:, :, 2], cmap='jet')
-        ax3.set_title('A - Amplitude')
-        plt.show()
-    return fitted_dataset
+    
+    fit_dset = np.array(dataset[start_fit_pixel:end_fit_pixel])
+    popt, lsq = leastsq(errf_multi, pin, args=(fit_dset, energy[start_fit_pixel:end_fit_pixel]), maxfev=2000)
+    
+    multi = dataset.like_data(multiple_scattering(energy, popt))
+    
 
+    multi.metadata['multiple_scattering'] = {'parameter': popt}
+    return multi
 
+    
 
 def drude_simulation(dset, e, ep, ew, tnm, eb):
     """probabilities of dielectric function eps relative to zero-loss integral (i0 = 1)
@@ -875,7 +1085,7 @@ def get_x_sections(z: int=0) -> dict:
             return 0
 
 
-def list_all_edges(z: Union[str, int]=0, verbose=False)->[str, dict]:
+def list_all_edges(z: Union[str, int]=0, verbose=False)->list[str, dict]:
     """List all ionization edges of an element with atomic number z
 
     Parameters
@@ -943,74 +1153,109 @@ def find_all_edges(edge_onset: float, maximal_chemical_shift: float=5.0, major_e
                         else:
                             text += new_text
 
-    return text
-
+    return text         
 
 def find_associated_edges(dataset: sidpy.Dataset) -> None:
     onsets = []
     edges = []
-    if 'edges' in dataset.metadata:
-        for key, edge in dataset.metadata['edges'].items():
-            if key.isdigit():
-                element = edge['element']
-                pre_edge = 0.  # edge['onset']-edge['start_exclude']
-                post_edge = edge['end_exclude'] - edge['onset']
-
-                for sym in edge['all_edges']:  # TODO: Could be replaced with exclude
-                    onsets.append(edge['all_edges'][sym]['onset'] + edge['chemical_shift']-pre_edge)
-                    edges.append([key, f"{element}-{sym}", onsets[-1]])
-        for key, peak in dataset.metadata['peak_fit']['peaks'].items():
-            if key.isdigit():
-                distance = dataset.get_spectral_dims(return_axis=True)[0].values[-1]
-                index = -1
-                for ii, onset in enumerate(onsets):
-                    if onset < peak['position'] < onset+post_edge:
-                        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(dataset: sidpy.Dataset) -> None:
-    if 'edges' in dataset.metadata:
-        white_lines = {}
-        for index, peak in dataset.metadata['peak_fit']['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 dataset.metadata:
-                            for key, edge in 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
+    if 'core_loss' in dataset.metadata:
+        if'edges' in dataset.metadata['core_loss']:
+            for key, edge in dataset.metadata['core_loss']['edges'].items():
+                if key.isdigit():
+                    """for sym in edge['all_edges']:  # TODO: Could be replaced with exclude
+                        onsets.append(edge['all_edges'][sym]['onset'] + edge['chemical_shift'])
+                        edges.append([key, f"{edge['element']}-{sym}", onsets[-1]])
+                    """
+                    onsets.append(edge['onset'])
+                    dataset.metadata['core_loss']['edges'][key]['associated_peaks'] = {}
+            if 'peak_fit' in dataset.metadata:
+                p = dataset.metadata['peak_fit']['peak_out_list']
+                for key, peak in enumerate(p):
+                    distances  = (onsets-peak[0])*-1
+                    distances[distances < -0.3] = 1e6
+                    if np.min(distances) < 50:
+                        index = np.argmin(distances)
+                        dataset.metadata['core_loss']['edges'][str(index)]['associated_peaks'][key] = peak
+
+                        
+                """for key, peak in dataset.metadata['peak_fit']['peaks'].items():
+                    if key.isdigit():
+                        distance = dataset.get_spectral_dims(return_axis=True)[0].values[-1]
+                        index = -1
+                        for ii, onset in enumerate(onsets):
+                            if onset < peak['position'] < onset+post_edge:
+                                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(dataset: sidpy.Dataset) -> dict:
+    white_lines_out ={'sum': {}, 'ratio': {}}
+    white_lines = []
+    if 'peak_fit' in dataset.metadata:
+        peaks = dataset.metadata['peak_fit']['peaks']
+    else:
+        return
+    for index, edge in dataset.metadata['core_loss']['edges'].items():
+        if index.isdigit():
+            if 'associated_peaks' in edge:
+                peaks = edge['associated_peaks']
+                
+                if edge['symmetry'][-2:] in ['L3', 'M5']:
+                    if 'L3' in edge['all_edges']:
+                        end_range1 = edge['all_edges']['L2']['onset'] + edge['chemical_shift']
+                        end_range2 = edge['all_edges']['L2']['onset']*2 - edge['all_edges']['L3']['onset'] + edge['chemical_shift'] 
+                        white_lines = ['L3', 'L2']
+                    elif 'M5' in edge['all_edges']:
+                        end_range1 = edge['all_edges']['M4']['onset'] + edge['chemical_shift']
+                        end_range2 = edge['all_edges']['M4']['onset']*2 - edge['all_edges']['M5']['onset'] + edge['chemical_shift'] 
+                        white_lines = ['M5', 'M4']
+                    else:
+                        return
+                    white_line_areas = [0., 0.]
+                    for key, peak in peaks.items():
+                        if str(key).isdigit():
+                            if peak[0] < end_range1:
+                                white_line_areas[0] += np.sqrt(2 * np.pi) * peak[1] * np.abs(peak[2]/np.sqrt(2 * np.log(2)))
+                            elif peak[0] < end_range2:
+                                white_line_areas[1] += np.sqrt(2 * np.pi) * peak[1] * np.abs(peak[2]/np.sqrt(2 * np.log(2)))
+
+                    edge['white_lines'] = {white_lines[0]: white_line_areas[0], white_lines[1]: white_line_areas[1]}
+                    
+                    reference_counts = edge['areal_density']*dataset.metadata['core_loss']['xsections'][int(index)].sum()
+                    white_lines_out['sum'][f"{edge['element']}-{white_lines[0]}+{white_lines[1]}"] = (white_line_areas[0] + white_line_areas[1])/reference_counts
+                    white_lines_out['ratio'][f"{edge['element']}-{white_lines[0]}/{white_lines[1]}"] = white_line_areas[0] / white_line_areas[1]
+    return white_lines_out
+
+
+    """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 dataset.metadata:
+                        for key, edge in 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
 
         dataset.metadata['peak_fit']['white_lines'] = white_lines
         dataset.metadata['peak_fit']['white_line_ratios'] = white_line_ratios
         dataset.metadata['peak_fit']['white_line_sums'] = white_line_sum
-        
+    """    
 
 def second_derivative(dataset: sidpy.Dataset, sensitivity: float=2.5) -> None:
     """Calculates second derivative of a sidpy.dataset"""
@@ -1042,9 +1287,10 @@ def second_derivative(dataset: sidpy.Dataset, sensitivity: float=2.5) -> None:
 
     noise_level_start = sensitivity * np.std(second_dif[3:50])
     noise_level_end = sensitivity * np.std(second_dif[start_end_noise: start_end_noise + 50])
-    slope = (noise_level_end - noise_level_start) / (len(energy_scale) - 400)
-    noise_level = noise_level_start + np.arange(len(energy_scale)) * slope
-    return second_dif, noise_level
+    #slope = (noise_level_end - noise_level_start) / (len(energy_scale) - 400)
+    #noise_level = noise_level_start #+ np.arange(len(energy_scale)) * slope
+    return second_dif , noise_level
+
 
 
 def find_edges(dataset: sidpy.Dataset, sensitivity: float=2.5) -> None:
@@ -1337,6 +1583,8 @@ def make_cross_sections(edges:dict, energy_scale:np.ndarray, e_0:float, coll_ang
     """
     for key in edges:
         if str(key).isdigit():
+            if edges[key]['z'] <1:
+                break
             edges[key]['data'] = xsec_xrpa(energy_scale, e_0 / 1000., edges[key]['z'], coll_angle,
                                            edges[key]['chemical_shift']) / 1e10  # from barnes to 1/nm^2
             if low_loss is not None:
@@ -1388,12 +1636,13 @@ def power_law_background(spectrum:np.ndarray, energy_scale:np.ndarray, fit_area:
     return background, p
 
 
-def cl_model(x, p, number_of_edges, xsec):
+def cl_model(xx, pp, number_of_edges, xsec):
     """ core loss model for fitting"""
-    y = (p[9] * np.power(x, (-p[10]))) + p[7] * x + p[8] * x * x
+    yy = pp[0] *  xx**pp[1] +  pp[2] + pp[3]* xx + pp[4] * xx * xx
     for i in range(number_of_edges):
-        y = y + p[i] * xsec[i, :]
-    return y
+        pp[i+5] = np.abs(pp[i+5])
+        yy = yy + pp[i+5] * xsec[i, :]
+    return yy
 
 
 def fit_edges2(spectrum, energy_scale, edges):
@@ -1467,7 +1716,7 @@ def fit_edges2(spectrum, energy_scale, edges):
     for key in edges:
         if key.isdigit():
             edges[key]['areal_density'] = p[int(key)+5]
-    print(p)
+    # print(p)
     edges['model'] = {}
     edges['model']['background'] = ( p[0] * np.power(x, -p[1])+ p[2]+ x**p[3] +  p[4] * x * x)
     edges['model']['background-poly_0'] = p[2]
@@ -1481,9 +1730,20 @@ def fit_edges2(spectrum, energy_scale, edges):
     edges['model']['fit_parameter'] = p
     edges['model']['fit_area_start'] = edges['fit_area']['fit_start']
     edges['model']['fit_area_end'] = edges['fit_area']['fit_end']
-
+    edges['model']['xsec'] = xsec
     return edges
 
+    
+def core_loss_model(energy_scale, pp, number_of_edges, xsec):
+    """ core loss model for fitting"""
+    xx = np.array(energy_scale)
+    yy = pp[0] *  xx**pp[1] +  pp[2] + pp[3]* xx + pp[4] * xx * xx
+    for i in range(number_of_edges):
+        pp[i+5] = np.abs(pp[i+5])
+        yy = yy + pp[i+5] * xsec[i, :]
+    return yy
+
+
 
 def fit_edges(spectrum, energy_scale, region_tags, edges):
     """fit edges for quantification"""
@@ -1615,19 +1875,35 @@ def get_spectrum(dataset, x=0, y=0, bin_x=1, bin_y=1):
         spectrum.data_type = 'Spectrum'
     return spectrum
 
-def find_peaks(dataset, fit_start, fit_end, sensitivity=2):
+def find_peaks(dataset, energy_scale):  #, fit_start, fit_end, sensitivity=2):
     """find peaks in spectrum"""
 
+    peaks, prop = scipy.signal.find_peaks(np.abs(dataset)+1, width=5)
+    results_half = scipy.signal.peak_widths(np.abs(dataset)+1, peaks, rel_height=0.5)[0]
+    
+    disp = energy_scale[1] - energy_scale[0]    
+    if len(peaks) > 0:
+        p_in = np.ravel([[energy_scale[peaks[i]], dataset[peaks[i]], results_half[i]*disp] for i in range(len(peaks))])
+    return p_in  # model, p_in
+
+def nothing():
+    pass
+    """
     if dataset.data_type.name == 'SPECTRAL_IMAGE':
-        spectrum = dataset.view.get_spectrum()
+        if hasattr(dataset.view, 'get_spectrum'):
+            spectrum = dataset.view.get_spectrum()
+        else:
+            spectrum = np.array(dataset[0,0])
+
     else:
         spectrum = np.array(dataset)
 
     energy_scale = dataset.get_spectral_dims(return_axis=True)[0].values
 
-    second_dif, noise_level = second_derivative(dataset, sensitivity=sensitivity)
-    [indices, _] = scipy.signal.find_peaks(-second_dif, noise_level)
-
+    """
+    
+    
+    """
     start_channel = np.searchsorted(energy_scale, fit_start)
     end_channel = np.searchsorted(energy_scale, fit_end)
     peaks = []
@@ -1636,34 +1912,26 @@ def find_peaks(dataset, fit_start, fit_end, sensitivity=2):
             peaks.append(index - start_channel)
 
     if 'model' in dataset.metadata:
-        model = dataset.metadata['model'][start_channel:end_channel]
+        model = dataset.metadata['model']
 
     elif energy_scale[0] > 0:
         if 'edges' not in dataset.metadata:
             return
         if 'model' not in dataset.metadata['edges']:
             return
-        model = dataset.metadata['edges']['model']['spectrum'][start_channel:end_channel]
+        model = dataset.metadata['edges']['model']['spectrum']
 
     else:
-        model = np.zeros(end_channel - start_channel)
+        model = np.zeros(len(energy_scale))
 
     energy_scale = energy_scale[start_channel:end_channel]
 
-    difference = np.array(spectrum)[start_channel:end_channel] - model
+    difference = np.array(spectrum - model)[start_channel:end_channel]
     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,
-                                                                                     difference,
-                                                                                     False))
-        fit = fit + model_smooth(energy_scale, p_out, False)
-
-    peak_model = np.zeros(len(spectrum))
-    peak_model[start_channel:end_channel] = fit
-
-    return peak_model, p_out
+    """
+    
 
 
 def find_maxima(y, number_of_peaks):
@@ -1691,7 +1959,6 @@ def find_maxima(y, number_of_peaks):
     peak_indices = np.argsort(peaks)
     return peaks[peak_indices]
 
-
 # 
 def model3(x, p, number_of_peaks, peak_shape, p_zl, pin=None, restrict_pos=0, restrict_width=0):
     """ model for fitting low-loss spectrum"""
@@ -1764,18 +2031,78 @@ def add_peaks(x, y, peaks, pin_in=None, peak_shape_in=None, shape='Gaussian'):
 
     return pin, peak_shape
 
+@jit
+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))
+
+
+@jit
+def gmm(x, p):
+    y = np.zeros(len(x))
+    number_of_peaks= int(len(p)/3)
+    for i in range(number_of_peaks):
+        index = i*3
+        p[index + 1] = p[index + 1]
+        # print(p[index + 1])
+        p[index + 2] = abs(p[index + 2])
+        y = y + gauss(x, p[index:index+3])
+    return y
+
+@jit
+def residuals3(pp, xx, yy):
+    err = (yy - gmm(xx, pp))
+    return err
 
+def gaussian_mixture_model(dataset, p_in=None):
+    peak_model = None
+    if isinstance(dataset, sidpy.Dataset):
+        if dataset.data_type.name == 'SPECTRAL_IMAGE':
+            if hasattr(dataset.view, 'get_spectrum'):
+                spectrum = dataset.view.get_spectrum()
+            else:
+                spectrum = dataset[0,0]
+            spectrum.data_type == 'SPECTRUM'
+        else:
+            spectrum = dataset
+        spectrum.data_type = 'SPECTRUM'
+        energy_scale = dataset.get_spectral_dims(return_axis=True)[0].values
+    else:
+        spectrum = np.array(dataset)
+        energy_scale = np.arange(len(spectrum))
+    spectrum = np.array(spectrum)    
+    #spectrum -= np.min(spectrum)-1
+    if p_in is None:
+        p_in = find_peaks(spectrum, energy_scale)
+    
+    p = fit_gmm(energy_scale, np.array(spectrum), list(p_in))
+    
+    peak_model = gmm(energy_scale, p)
+    return peak_model, p
+
+def fit_gmm(x, y, pin):
+    """fit a Gaussian mixture model to a spectrum"""
+    [p, _] = leastsq(residuals3, pin, args=(x, y),maxfev = 10000)
+    return p    
+
+              
 def fit_model(x, y, pin, number_of_peaks, peak_shape, p_zl, restrict_pos=0, restrict_width=0):
     """model for fitting low-loss spectrum"""
 
     pin_original = pin.copy()
 
-    def residuals3(pp, xx, yy):
-        err = (yy - model3(xx, pp, number_of_peaks, peak_shape, p_zl, pin_original, restrict_pos,
-                           restrict_width)) / np.sqrt(np.abs(yy))
-        return err
+    
 
-    [p, _] = leastsq(residuals3, pin, args=(x, y))
+    [p, _] =  scipy.optimize.leastsq(residuals3, pin, args=(x, y),maxfev = 19400)
     # p2 = p.tolist()
     # p3 = np.reshape(p2, (number_of_peaks, 3))
     # sort_pin = np.argsort(p3[:, 0])
@@ -2028,4 +2355,4 @@ def get_spectrum_eels_db(formula=None, edge=None, title=None, element=None):
             print(parameters['TITLE'])
     print(f'found {len(reference_spectra.keys())} spectra in EELS database)')
 
-    return reference_spectra
+    return reference_spectra