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

pyTEMlib/eds_tools.py

@@ -24,7 +24,8 @@ from scipy.interpolate import interp1d, splrep  # splev, splint
 from scipy import interpolate
 from scipy.signal import peak_prominences
 from scipy.ndimage import gaussian_filter
-
+from sklearn.mixture import GaussianMixture
+from sklearn.cluster import KMeans
 import scipy.constants as const
 
 from scipy import constants
@@ -39,67 +40,519 @@ import requests
 
 from scipy.optimize import leastsq  # least square fitting routine fo scipy
 
+import sidpy
+
 import pickle  # pkg_resources
-import pyTEMlib.eels_tools as eels
+import pyTEMlib.eels_tools
+from pyTEMlib.xrpa_x_sections import x_sections
+
+elements_list = pyTEMlib.eels_tools.elements
+
+shell_occupancy = {'K1': 2, 'L1': 2, 'L2': 2, 'L3': 4, 'M1': 2, 'M2': 2, 'M3': 4, 'M4': 4, 'M5': 6,
+                   'N1': 2, 'N2': 2, 'N3': 4, 'N4': 4, 'N5': 6, 'N6': 6, 'N7': 8,
+                   'O1': 2, 'O2': 2, 'O3': 4, 'O4': 4, 'O5': 6, 'O6': 6, 'O7': 8, 'O8': 8, 'O9': 10}
+
 
-shell_occupancy={'K1':2, 'L1':2, 'L2':2, 'L3':4, 'M1':2, 'M2':2, 'M3':4,'M4':4,'M5':6, 
-                 'N1':2, 'N2':2,' N3':4,'N4':4,'N5':6, 'N6':6,'N7':8,
-                 'O1':2, 'O2':2,' O3':4,'O4':4,'O5':6, 'O6':6,'O7':8, 'O8':8, 'O9': 10 }
+def detector_response(dataset):
+    tags = dataset.metadata['experiment']
 
-def detector_response(detector_definition, energy_scale):
+    tags['acceleration_voltage_V'] = tags['microscope']['acceleration_voltage_V']
+    energy_scale = dataset.get_spectral_dims(return_axis=True)[0]
+    if 'start_channel' not in tags['detector']:
+        tags['detector']['start_channel'] = np.searchsorted(energy_scale, 100)
+
+    start = tags['detector']['start_channel']
+    detector_efficiency = np.zeros(len(dataset))
+    detector_efficiency[start:] += get_detector_response(tags, energy_scale[start:])
+    tags['detector']['detector_efficiency'] = detector_efficiency
+    return detector_efficiency
+
+
+def get_detector_response(detector_definition, energy_scale):
     """
-    Parameters
+    Calculates response of Si drift detector for EDS spectrum background based on detector parameters
+
+    Parameters:
     ----------
+    detector_definition: dictionary
+        definition of detector
+    energy_scale: numpy array (1 dim)
+        energy scale of spectrum should start at about 100eV!!
 
+    Return:
+    -------
+    response: numpy array with length(energy_scale)
+        detector response
 
     Example
     -------
 
-    tags = {}
-
-    tags['acceleration_voltage_V'] = 30000
+    tags ={}
+    tags['acceleration_voltage_V'] = 200000
 
     tags['detector'] ={}
-    tags['detector']['layers'] ={}
 
     ## layer thicknesses of commen materials in EDS detectors in m
-    tags['detector']['layers']['alLayer'] = {}
-    tags['detector']['layers']['alLayer']['thickness'] = 30 *1e-9    # in m
-    tags['detector']['layers']['alLayer']['Z'] = 13
-
-    tags['detector']['layers']['deadLayer'] = {}
-    tags['detector']['layers']['deadLayer']['thickness'] =  100 *1e-9  # in m
-    tags['detector']['layers']['deadLayer']['Z'] = 14
-
-    tags['detector']['layers']['window'] = {}
-    tags['detector']['layers']['window']['thickness'] =  100 *1e-9  # in m
-    tags['detector']['layers']['window']['Z'] = 6
-
-    tags['detector']['detector'] = {}
-    tags['detector']['detector']['thickness'] = 45 * 1e-3  # in m
-    tags['detector']['detector']['Z'] = 14
-    tags['detector']['detector']['area'] = 30 * 1e-6 #in m2
-    
-    energy_scale = np.linspace(.1,60,1199)*1000 i eV
-    detector_response(tags, energy_scale)
+    tags['detector']['Al_thickness'] = 0.03 * 1e-6  # in m
+    tags['detector']['Be_thickness'] = 0.  # in m
+    tags['detector']['Au_thickness'] = 0.0 * 1e-6  # in m
+    tags['detector']['Par_thickness'] =  0 *1e-6  # in m   # Window
+
+    tags['detector']['SiDeadThickness'] = .03 *1e-6  # in m
+   
+    tags['detector']['SiLiveThickness'] = 0.05  # in m
+    tags['detector']['detector_area'] = 30 * 1e-6 #in m2
+    tags['detector']['resolution'] = 125  # in eV
+        
+    energy_scale = np.linspace(.01,20,1199)*1000 # i eV
+    start = np.searchsorted(spectrum.energy, 100)
+    energy_scale = spectrum.energy[start:]
+    detector_Efficiency= pyTEMlib.eds_tools.detector_response(tags, spectrum.energy[start:])
+
+    p = np.array([1, 37, .3])/10000*3
+    E_0= 200000
+    background = np.zeros(len(spectrum))
+    background[start:] = detector_Efficiency * (p[0] + p[1]*(E_0-energy_scale)/energy_scale + p[2]*(E_0-energy_scale)**2/energy_scale)
+
+
+    plt.figure()
+    plt.plot(spectrum.energy, spectrum, label = 'spec')
+    plt.plot(spectrum.energy, background, label = 'background')
+    plt.show()
+
     """
     response = np.ones(len(energy_scale))
-    x_sections = eels.get_x_sections()
+    x_sections = pyTEMlib.eels_tools.get_x_sections()
     
-    for key in detector_definition['layers']:
-        Z = detector_definition['layers'][key]['Z']
-        t = detector_definition['layers'][key]['thickness']
+    def get_absorption(Z, t):
         photoabsorption = x_sections[str(Z)]['dat']/1e10/x_sections[str(Z)]['photoabs_to_sigma']
-        lin = interp1d(x_sections[str(Z)]['ene'], photoabsorption,kind='linear') 
-        mu = lin(energy_scale) * x_sections[str(Z)]['nominal_density']*100. #1/cm -> 1/m
-
-        absorption = np.exp(-mu * t)
-        response = response*absorption
-    Z = detector_definition['detector']['Z']
-    t = detector_definition['detector']['thickness']    
-    photoabsorption = x_sections[str(Z)]['dat']/1e10/x_sections[str(Z)]['photoabs_to_sigma']
-    lin = interp1d(x_sections[str(Z)]['ene']/1000., photoabsorption,kind='linear') 
-    mu = lin(energy_scale) * x_sections[str(Z)]['nominal_density']*100. #1/cm -> 1/m
-    response = response*(1.0 - np.exp(-mu * t))# * oo4pi;
-    return(response)
+        lin = interp1d(x_sections[str(Z)]['ene'], photoabsorption, kind='linear') 
+        mu = lin(energy_scale) * x_sections[str(Z)]['nominal_density']*100.  #1/cm -> 1/m
+        return np.exp(-mu * t)
+    
+    if 'Al_thickness' in  detector_definition['detector']:
+        response *= get_absorption(13, detector_definition['detector']['Al_thickness'])
+    if 'Be_thickness' in  detector_definition['detector']:
+        response *= get_absorption(5, detector_definition['detector']['Be_thickness'])
+    if 'Au_thickness' in  detector_definition['detector']:
+        response *= get_absorption(79, detector_definition['detector']['Au_thickness'])
+    if 'Par_thickness' in  detector_definition['detector']:
+        response *= get_absorption(6, detector_definition['detector']['Par_thickness'])
+    if 'SiDeadThickness' in  detector_definition['detector']:
+        response *= get_absorption(14, detector_definition['detector']['SiDeadThickness'])
+        
+    if 'SiLiveThickness' in  detector_definition['detector']:
+        response *= 1-get_absorption(14, detector_definition['detector']['SiLiveThickness'])
+    return response
+
+
+def detect_peaks(dataset, minimum_number_of_peaks=30):
+    if not isinstance(dataset, sidpy.Dataset):
+        raise TypeError('Needs an sidpy dataset')
+    if not dataset.data_type.name == 'SPECTRUM':
+        raise TypeError('Need a spectrum')
+
+    energy_scale = dataset.get_spectral_dims(return_axis=True)[0]
+    if 'detector' not in dataset.metadata:
+        if 'energy_resolution' not in dataset.metadata['detector']:
+            dataset.metadata['detector']['energy_resolution'] = 138
+            print('Using energy resolution of 138 eV')
+        if 'start_channel' not in dataset.metadata['detector']:
+            dataset.metadata['detector']['start_channel'] = start = np.searchsorted(energy_scale, 100)
+    resolution = dataset.metadata['detector']['energy_resolution']
+
+    start = dataset.metadata['detector']['start_channel']
+    ## we use half the width of the resolution for smearing
+    width = int(np.ceil(resolution/(energy_scale[1]-energy_scale[0])/2)+1)
+    new_spectrum =  scipy.signal.savgol_filter(np.array(dataset)[start:], width, 2) ## we use half the width of the resolution for smearing
+    prominence = 10
+    minor_peaks, _  = scipy.signal.find_peaks(new_spectrum, prominence=prominence)
+    
+    while len(minor_peaks) > minimum_number_of_peaks:
+        prominence+=10
+        minor_peaks, _  = scipy.signal.find_peaks(new_spectrum, prominence=prominence)
+    return np.array(minor_peaks)+start
+
+def find_elements(spectrum, minor_peaks):
+    if not isinstance(spectrum, sidpy.Dataset):
+        raise TypeError(' Need a sidpy dataset')
+    energy_scale = spectrum.get_spectral_dims(return_axis=True)[0]
+    elements = []
+    for peak in minor_peaks:
+        found = False
+        for element in range(3,82):
+            if 'lines' in x_sections[str(element)]:
+                if 'K-L3' in x_sections[str(element)]['lines']:
+                    if abs(x_sections[str(element)]['lines']['K-L3']['position']- energy_scale[peak]) <10:
+                        found = True
+                        if  x_sections[str(element)]['name'] not in elements:
+                            elements.append( x_sections[str(element)]['name'])
+                if not found:
+                    if 'K-L2' in x_sections[str(element)]['lines']:
+                        if abs(x_sections[str(element)]['lines']['K-L2']['position']- energy_scale[peak]) <10:
+                            found = True
+                            if  x_sections[str(element)]['name'] not in elements:
+                                elements.append( x_sections[str(element)]['name'])
+                if not found:
+                    if 'L3-M5' in x_sections[str(element)]['lines']:
+                        if abs(x_sections[str(element)]['lines']['L3-M5']['position']- energy_scale[peak]) <30:
+                              if  x_sections[str(element)]['name'] not in elements:
+                                    elements.append( x_sections[str(element)]['name'])
+    return elements
+
+def get_x_ray_lines(spectrum, elements):
+    out_tags = {}
+    alpha_K = 1e6
+    alpha_L = 6.5e7
+    alpha_M = 8*1e8  # 2.2e10
+    # My Fit
+    alpha_K = .9e6
+    alpha_L = 6.e7
+    alpha_M = 6*1e8 #  2.2e10
+    # omega_K = Z**4/(alpha_K+Z**4)
+    # omega_L = Z**4/(alpha_L+Z**4)
+    # omega_M = Z**4/(alpha_M+Z**4)
+    energy_scale = spectrum.get_spectral_dims(return_axis=True)[0]
+    for element in elements:
+        atomic_number = elements_list.index(element)
+        out_tags[element] ={'Z': atomic_number}
+
+        if 'K-L3' in x_sections[str(atomic_number)]['lines']:
+            if x_sections[str(atomic_number)]['lines']['K-L3']['position'] < energy_scale[-1]:
+                height = spectrum[np.searchsorted(energy_scale, x_sections[str(atomic_number)]['lines']['K-L3']['position'] )].compute()
+                out_tags[element]['K-family'] = {'height': height}
+                if 'K' in x_sections[str(atomic_number)]['fluorescent_yield']:
+                    out_tags[element]['K-family']['yield'] = x_sections[str(atomic_number)]['fluorescent_yield']['K']
+                else:
+                    out_tags[element]['K-family']['yield'] = atomic_number**4/(alpha_K+atomic_number**4)/4/1.4
+
+        if 'L3-M5' in x_sections[str(atomic_number)]['lines']:
+            if x_sections[str(atomic_number)]['lines']['L3-M5']['position'] < energy_scale[-1]:
+                height = spectrum[np.searchsorted(energy_scale, x_sections[str(atomic_number)]['lines']['L3-M5']['position'] )].compute()
+                out_tags[element]['L-family'] = {'height': height}
+                if 'L' in x_sections[str(atomic_number)]['fluorescent_yield']:
+                    out_tags[element]['L-family']['yield'] = x_sections[str(atomic_number)]['fluorescent_yield']['L']
+                else:
+                    out_tags[element]['L-family']['yield'] = (atomic_number**4/(alpha_L+atomic_number**4))**2
+
+        if 'M5-N6' in x_sections[str(atomic_number)]['lines']:
+            if x_sections[str(atomic_number)]['lines']['M5-N6']['position'] < energy_scale[-1]:
+                height = spectrum[np.searchsorted(energy_scale, x_sections[str(atomic_number)]['lines']['M5-N6']['position'] )].compute()
+                out_tags[element]['M-family'] = {'height': height}
+                if 'M' in x_sections[str(atomic_number)]['fluorescent_yield']:
+                    out_tags[element]['M-family']['yield'] = x_sections[str(atomic_number)]['fluorescent_yield']['M']
+                else:
+                    out_tags[element]['M-family']['yield'] = (atomic_number**4/(alpha_M+atomic_number**4))**2
+
+        for key, line in x_sections[str(atomic_number)]['lines'].items():
+            other = True
+            if line['weight'] > 0.01 and line['position'] < 3e4:
+                if 'K-family' in out_tags[element]:
+                    if key[0] == 'K':
+                        other = False
+                        out_tags[element]['K-family'][key]=line
+                if 'L-family' in out_tags[element]:
+                    if key[:2] in ['L2', 'L3']:
+                        other = False
+                        out_tags[element]['L-family'][key]=line
+                if 'M-family' in out_tags[element]:
+                    if key[:2] in ['M5', 'M4']:
+                        other = False
+                        out_tags[element]['M-family'][key]=line
+                if other:
+                    if 'other' not in out_tags[element]:
+                        out_tags[element]['other'] = {}
+                    height = spectrum[np.searchsorted(energy_scale, x_sections[str(atomic_number)]['lines'][key]['position'] )].compute()
+                    out_tags[element]['other'][key]=line
+                    out_tags[element]['other'][key]['height'] = height
+      
+        xs = get_eds_cross_sections(atomic_number)
+        if 'K' in xs and 'K-family' in out_tags[element]:
+            out_tags[element]['K-family']['ionization_x_section'] = xs['K']
+        if 'L' in xs and 'L-family' in out_tags[element]:
+            out_tags[element]['L-family']['ionization_x_section'] = xs['L']
+        if 'M' in xs and 'M-family' in out_tags[element]:
+            out_tags[element]['M-family']['ionization_x_section'] = xs['M']
+
+    """
+    We really should use the sum of the family
+    for key, x_lines in out_tags.items():
+        if 'K-family' in x_lines:
+            xs = pyTEMlib.eels_tools.xsec_xrpa(np.arange(100)+x_sections[str(x_lines['Z'])]['K1']['onset'], 200,x_lines['Z'], 100).sum()
+
+            x_lines['K-family']['ionization_x_section'] = xs
+            
+        if 'L-family' in x_lines:
+            xs = pyTEMlib.eels_tools.xsec_xrpa(np.arange(100)+x_sections[str(x_lines['Z'])]['L3']['onset'], 200,x_lines['Z'], 100).sum()
+            x_lines['L-family']['ionization_x_section'] = xs
+        if 'M-family' in x_lines:
+            xs = pyTEMlib.eels_tools.xsec_xrpa(np.arange(100)+x_sections[str(x_lines['Z'])]['M5']['onset'], 200,x_lines['Z'], 100).sum()
+            x_lines['M-family']['ionization_x_section'] = xs
+    """
+    if 'EDS' not in spectrum.metadata:
+        spectrum.metadata['EDS'] = {}
+
+    spectrum.metadata['EDS']['lines'] = out_tags
+    return out_tags
+
 
+def getFWHM(E, E_ref, FWHM_ref):
+    return np.sqrt(2.5*(E-E_ref)+FWHM_ref**2)
+
+def gaussian(enrgy_scale, mu, FWHM):
+    sig = FWHM/2/np.sqrt(2*np.log(2))
+    return np.exp(-np.power(np.array(enrgy_scale) - mu, 2.) / (2 * np.power(sig, 2.)))
+
+def get_peak(E, energy_scale):
+    E_ref = 5895.0
+    FWHM_ref = 136 #eV
+    FWHM  = getFWHM(E, E_ref, FWHM_ref)
+    gaus = gaussian(energy_scale, E, FWHM)
+
+    return gaus /(gaus.sum()+1e-12)
+
+
+def initial_model_parameter(spectrum):
+    tags = spectrum.metadata['EDS']['lines']
+    energy_scale = spectrum.get_spectral_dims(return_axis=True)[0]
+    p = []
+    peaks = []
+    keys = []
+    for element, lines in tags.items():
+        if 'K-family' in lines:
+            model = np.zeros(len(energy_scale))
+            for line, info in lines['K-family'].items():
+                if line[0] == 'K':
+                    model += get_peak(info['position'], energy_scale)*info['weight']
+            lines['K-family']['peaks'] = model/model.sum()
+            lines['K-family']['height'] /= lines['K-family']['peaks'].max()
+            p.append(lines['K-family']['height'])
+            peaks.append(lines['K-family']['peaks'])
+            keys.append(element+':K-family')
+        if 'L-family' in lines:
+            model = np.zeros(len(energy_scale))
+            for line, info in lines['L-family'].items():
+                if line[0] == 'L':
+                    model += get_peak(info['position'], energy_scale)*info['weight']
+            lines['L-family']['peaks'] = model/model.sum()
+            lines['L-family']['height'] /= lines['L-family']['peaks'].max()
+            p.append(lines['L-family']['height'])
+            peaks.append(lines['L-family']['peaks'])
+            keys.append(element+':L-family')
+        if 'M-family' in lines:
+            model = np.zeros(len(energy_scale))
+            for line, info in lines['M-family'].items():
+                if line[0] == 'M':
+                    model += get_peak(info['position'], energy_scale)*info['weight']
+            lines['M-family']['peaks'] = model/model.sum()
+            lines['M-family']['height'] /= lines['M-family']['peaks'].max()
+            p.append(lines['M-family']['height'])
+            peaks.append(lines['M-family']['peaks'])
+            keys.append(element+':M-family')
+            
+        if 'other' in lines:
+            for line, info in lines['other'].items():
+                info['peak'] =  get_peak(info['position'], energy_scale)
+                peaks.append(info['peak'])
+                p.append(info['height'])
+                keys.append(element+':other:'+line)
+
+    #p.extend([300, 10, 1.e-04])
+    # p.extend([1, 300, -.02])
+    p.extend([1e7, 1e-3, 1500, 20])
+    return np.array(peaks), np.array(p), keys
+
+def get_model(spectrum, start=100):
+
+    peaks, pp, keys = initial_model_parameter(spectrum)
+    model = np.zeros(len(spectrum))
+    energy_scale = spectrum.get_spectral_dims(return_axis=True)[0].values
+    pp= spectrum.metadata['EDS']['parameters']
+    for i in range(len(pp) - 3):
+        model += peaks[i] * pp[i]
+    if 'detector_efficiency' in spectrum.metadata['experiment']['detector'].keys():
+        detector_efficiency = spectrum.metadata['experiment']['detector']['detector_efficiency']
+    else:
+        detector_efficiency = None
+    E_0 = spectrum.metadata['experiment']['acceleration_voltage_V']
+
+    if detector_efficiency is not None:
+        model[start:] += detector_efficiency[start:] * (pp[-3] + pp[-2] * (E_0 - energy_scale) / energy_scale +
+                                                        pp[-1] * (E_0 - energy_scale) ** 2 / energy_scale)
+
+    return model
+
+def fit_model(spectrum, elements, use_detector_efficiency=False):
+    out_tags = get_x_ray_lines(spectrum, elements)
+    peaks, pin, keys = initial_model_parameter(spectrum)
+    energy_scale = spectrum.get_spectral_dims(return_axis=True)[0].values
+
+    if 'detector' in spectrum.metadata['experiment'].keys():
+        if 'start_channel' not in spectrum.metadata['experiment']['detector']:
+            spectrum.metadata['experiment']['detector']['start_channel'] = np.searchsorted(energy_scale, 100)
+        if 'detector_efficiency' in spectrum.metadata['experiment']['detector'].keys():
+            if use_detector_efficiency:
+                detector_efficiency = spectrum.metadata['experiment']['detector']['detector_efficiency']
+        else:
+            use_detector_efficiency = False
+    else:
+        print('need detector information to fit spectrum')
+        return
+    start = spectrum.metadata['experiment']['detector']['start_channel']
+    energy_scale = energy_scale[start:]
+
+    E_0= spectrum.metadata['experiment']['acceleration_voltage_V']
+
+    def residuals(pp, yy):
+        #get_model(peaks, pp, detector_efficiency=None)
+        model = np.zeros(len(yy))
+        for i in range(len(pp)-4):
+            model += peaks[i]*pp[i]
+        # pp[-3:] = np.abs(pp[-3:])
+
+        if use_detector_efficiency:
+            bremsstrahlung = pp[-4] / (energy_scale + pp[-3] * energy_scale**2 + pp[-2] * energy_scale**.5) - pp[-1]
+
+            model[start:] += detector_efficiency[start:] * bremsstrahlung
+            #(pp[-3] + pp[-2] * (E_0 - energy_scale) / energy_scale +
+            #                                                pp[-1] * (E_0-energy_scale) ** 2 / energy_scale))
+
+        err = np.abs((yy - model)[start:])  # /np.sqrt(np.abs(yy[start:])+1e-12)
+
+        return err
+
+    y = np.array(spectrum)  # .compute()
+    [p, _] = leastsq(residuals, pin, args=(y))
+
+    # print(pin[-6:], p[-6:])
+
+    update_fit_values(out_tags, p)
+
+
+    if 'EDS' not in spectrum.metadata:
+        spectrum.metadata['EDS'] = {}
+    spectrum.metadata['EDS']['lines'] = out_tags
+
+    return np.array(peaks), np.array(p)
+
+
+def update_fit_values(out_tags, p):
+    index = 0
+    for element, lines in out_tags.items():
+        if 'K-family' in lines:
+            lines['K-family']['height'] = p[index]
+            index += 1
+        if 'L-family' in lines:
+            lines['L-family']['height'] = p[index]
+            index += 1
+        if 'M-family' in lines:
+            lines['M-family']['height'] =p[index]
+            index += 1
+        if 'other' in lines:
+            for line, info in lines['other'].items():
+                info['height'] = p[index]
+                index += 1
+                
+
+def get_eds_xsection(Xsection, energy_scale, start_bgd, end_bgd):
+    background = pyTEMlib.eels_tools.power_law_background(Xsection, energy_scale, [start_bgd, end_bgd], verbose=False)
+    cross_section_core = Xsection- background[0]
+    cross_section_core[cross_section_core < 0] = 0.0
+    cross_section_core[energy_scale < end_bgd] = 0.0
+    return cross_section_core
+
+
+def get_eds_cross_sections(z):
+    energy_scale = np.arange(10, 20000)
+    Xsection = pyTEMlib.eels_tools.xsec_xrpa(energy_scale, 200, z, 400.)
+    edge_info = pyTEMlib.eels_tools.get_x_sections(z)
+    eds_cross_sections = {}
+    if 'K1' in edge_info:
+        start_bgd = edge_info['K1']['onset'] * 0.8
+        end_bgd = edge_info['K1']['onset']  - 5
+        if start_bgd > end_bgd:
+            start_bgd = end_bgd-100
+        if start_bgd > energy_scale[0] and end_bgd< energy_scale[-1]-100:
+            eds_xsection = get_eds_xsection(Xsection, energy_scale, start_bgd, end_bgd)
+            eds_xsection = Xsection - eds_xsection
+            eds_xsection[eds_xsection<0] = 0.
+            start_sum = np.searchsorted(energy_scale, edge_info['K1']['onset'])
+            eds_cross_sections['K'] = eds_xsection[start_sum:start_sum+200].sum() 
+    if 'L3' in edge_info:
+        start_bgd = edge_info['L3']['onset'] * 0.8
+        end_bgd = edge_info['L3']['onset']  - 5
+        if start_bgd > end_bgd:
+            start_bgd = end_bgd-100
+        if start_bgd > energy_scale[0] and end_bgd< energy_scale[-1]-100:
+            eds_xsection = get_eds_xsection(Xsection, energy_scale, start_bgd, end_bgd)
+            eds_xsection = Xsection - eds_xsection
+            eds_xsection[eds_xsection<0] = 0.
+            start_sum = np.searchsorted(energy_scale, edge_info['L3']['onset'])
+            eds_cross_sections['L'] = eds_xsection[start_sum:start_sum+200].sum() 
+    if 'M5' in edge_info:
+        start_bgd = edge_info['M5']['onset'] * 0.8
+        end_bgd = edge_info['M5']['onset']  - 5
+        if start_bgd > end_bgd:
+            start_bgd = end_bgd-100
+        if start_bgd > energy_scale[0] and end_bgd< energy_scale[-1]-100:
+            eds_xsection = get_eds_xsection(Xsection, energy_scale, start_bgd, end_bgd)
+            eds_xsection = Xsection - eds_xsection
+            eds_xsection[eds_xsection<0] = 0.
+            start_sum = np.searchsorted(energy_scale, edge_info['M5']['onset'])
+            eds_cross_sections['M'] = eds_xsection[start_sum:start_sum+200].sum() 
+    return eds_cross_sections
+
+
+def get_phases(dataset, mode='kmeans', number_of_phases=4):
+    X_vec = np.array(dataset).reshape(dataset.shape[0]*dataset.shape[1], dataset.shape[2])
+    X_vec = np.divide(X_vec.T, X_vec.sum(axis=1)).T
+    if mode != 'kmeans':
+        gmm = GaussianMixture(n_components=number_of_phases, covariance_type="full") #choose number of components
+
+        gmm_results = gmm.fit(np.array(X_vec)) #we can intelligently fold the data and perform GM
+        gmm_labels = gmm_results.fit_predict(X_vec)
+
+        dataset.metadata['gaussian_mixing_model'] = {'map': gmm_labels.reshape(dataset.shape[0], dataset.shape[1]),
+                                                    'covariances': gmm.covariances_,
+                                                    'weights': gmm.weights_,
+                                                    'means':  gmm_results.means_}
+    else:
+        km = KMeans(number_of_phases, n_init =10) #choose number of clusters
+        km_results = km.fit(np.array(X_vec)) #we can intelligently fold the data and perform Kmeans
+        dataset.metadata['kmeans'] = {'map': km_results.labels_.reshape(dataset.shape[0], dataset.shape[1]),
+                                      'means': km_results.cluster_centers_}
+
+def plot_phases(dataset, image=None, survey_image=None):
+    if survey_image is not None:
+        ncols = 3
+    else:
+        ncols = 2
+    axis_index = 0
+    fig, axes = plt.subplots(nrows=1, ncols=ncols, figsize = (10,3))
+    if survey_image is not None:
+        im = axes[0].imshow(survey_image.T)
+        axis_index += 1
+    #if 'gaussian_mixing_model' in dataset.metadata:
+    #    phase_spectra = dataset.metadata['gaussian_mixing_model']['means']
+    #   map = dataset.metadata['gaussian_mixing_model']['map']
+    #el
+    if 'kmeans' in dataset.metadata:
+        phase_spectra = dataset.metadata['kmeans']['means']
+        map = dataset.metadata['kmeans']['map']
+
+    cmap = plt.get_cmap('jet', len(phase_spectra))
+    im = axes[axis_index].imshow(image.T,cmap='gray')
+    im = axes[axis_index].imshow(map.T, cmap=cmap,vmin=np.min(map) - 0.5,
+                          vmax=np.max(map) + 0.5,alpha=0.2)
+    
+    cbar = fig.colorbar(im, ax=axes[axis_index])
+    cbar.ax.set_yticks(np.arange(0, len(phase_spectra) ))
+    cbar.ax.set_ylabel("GMM Phase", fontsize = 14)
+    axis_index += 1
+    for index, spectrum in enumerate(phase_spectra):
+        axes[axis_index].plot(dataset.energy/1000, spectrum, color = cmap(index), label=str(index))
+        axes[axis_index].set_xlabel('energy (keV)')
+    plt.legend()
+    plt.tight_layout()
+    plt.show()
+    return fig