pyTEMlib 0.2025.4.1__py3-none-any.whl → 0.2025.9.1__py3-none-any.whl

pyTEMlib/eds_tools.py

@@ -10,51 +10,47 @@ Sources:
    
 Units:
     everything is in SI units, except length is given in nm and angles in mrad.
-
 Usage:
     See the notebooks for examples of these routines
 
 All the input and output is done through a dictionary which is to be found in the meta_data
 attribute of the sidpy.Dataset
 """
-import numpy as np
-
-import scipy
-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
-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 os
+import csv
+import json
+import xml
 
-import requests
+import numpy as np
+import matplotlib.pyplot as plt
 
-from scipy.optimize import leastsq  # least square fitting routine fo scipy
+import scipy
+import scipy.interpolate  # use interp1d,
+import scipy.optimize  # leastsq  # least square fitting routine fo scipy
+import sklearn  # .mixture import GaussianMixture
 
 import sidpy
 
-import pickle  # pkg_resources
-import pyTEMlib.eels_tools
-from pyTEMlib.xrpa_x_sections import x_sections
+import pyTEMlib
+import pyTEMlib.file_reader
+from .utilities import elements
+from . eds_xsections import quantify_cross_section, quantification_k_factors
+from .config_dir import config_path
+elements_list = elements
 
-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}
+def detector_response(dataset):
+    """
+    Calculate the detector response for the given dataset based on its metadata.
 
+    Parameters:
+    - dataset: A sidpy.Dataset object containing the spectral data and metadata.
 
-def detector_response(dataset):
-    tags = dataset.metadata['experiment']
+    Returns:
+    - A numpy array representing the detector efficiency across the energy scale.
+    """
+    tags = dataset.metadata['EDS']
 
     energy_scale = dataset.get_spectral_dims(return_axis=True)[0]
     if 'start_channel' not in tags['detector']:
@@ -69,7 +65,8 @@ def detector_response(dataset):
 
 def get_detector_response(detector_definition, energy_scale):
     """
-    Calculates response of Si drift detector for EDS spectrum background based on detector parameters
+    Calculates response of Si drift detector for EDS spectrum background based 
+    on detector parameters
 
     Parameters:
     ----------
@@ -91,19 +88,18 @@ def get_detector_response(detector_definition, energy_scale):
 
     tags['detector'] ={}
 
-    ## layer thicknesses of commen materials in EDS detectors in m
-    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
-   
+    ## layer thicknesses of common materials in EDS detectors in m
+    tags['detector']['layers'] = {13: {'thickness':= 0.05*1e-6, 'Z': 13, 'element': 'Al'},
+                                  6: {'thickness':= 0.15*1e-6, 'Z': 6, 'element': 'C'}
+                                  }
+    tags['detector']['SiDeadThickness'] = .13 *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
+    tags['detector']['energy_resolution'] = 125  # in eV
+    tags['detector']['start_energy'] = 120  # in eV
+    tags['detector']['start_channel'] = np.searchsorted(spectrum.energy_scale.values,120)
+
+    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:])
@@ -111,8 +107,9 @@ def get_detector_response(detector_definition, energy_scale):
     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)
-
+    bremsstrahlung =  p[0] + p[1]*(E_0-energy_scale)/energy_scale 
+     bremsstrahlung += p[2]*(E_0-energy_scale)**2/energy_scale
+    background[start:] = detector_Efficiency * bremsstrahlung
 
     plt.figure()
     plt.plot(spectrum.energy, spectrum, label = 'spec')
@@ -122,174 +119,223 @@ def get_detector_response(detector_definition, energy_scale):
     """
     response = np.ones(len(energy_scale))
     x_sections = pyTEMlib.eels_tools.get_x_sections()
-    
-    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
+
+    def get_absorption(z, t):
+        photoabsorption = x_sections[str(z)]['dat']/1e10/x_sections[str(z)]['photoabs_to_sigma']
+        lin = scipy.interpolate.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'])
+
+    for layer in detector_definition['detector']['layers'].values():
+        if layer['Z'] != 14:
+            response *= get_absorption(layer['Z'], layer['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):
+def detect_peaks(dataset, minimum_number_of_peaks=30, prominence=10):
+    """
+    Detect peaks in the given spectral dataset.
+
+    Parameters:
+    - dataset: A sidpy.Dataset object containing the spectral data.
+    - minimum_number_of_peaks: The minimum number of peaks to detect.
+    - prominence: The prominence threshold for peak detection.
+
+    Returns:
+    - An array of indices representing the positions of detected peaks in the spectrum.
+    """
     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']
+    energy_scale = dataset.get_spectral_dims(return_axis=True)[0].values
+    if 'EDS' not in dataset.metadata:
+        dataset.metadata['EDS'] = {}
+    if 'detector' not in dataset.metadata['EDS']:
+        raise ValueError('No detector information found, add detector dictionary to metadata')
+
+    if 'energy_resolution' not in dataset.metadata['EDS']['detector']:
+        dataset.metadata['EDS']['detector']['energy_resolution'] = 138
+        print('Using energy resolution of 138 eV')
+    if 'start_channel' not in dataset.metadata['EDS']['detector']:
+        dataset.metadata['EDS']['detector']['start_channel'] =  np.searchsorted(energy_scale, 100)
+
+    resolution = dataset.metadata['EDS']['detector']['energy_resolution']
+    start = dataset.metadata['EDS']['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
+    new_spectrum =  scipy.signal.savgol_filter(np.array(dataset)[start:], width, 2)
+
     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):
+    """
+    Identify elements present in the spectrum based on detected minor peaks.
+
+    Parameters:
+    - spectrum: A sidpy.Dataset object containing the spectral data.
+    - minor_peaks: An array of indices representing the positions of
+                   minor peaks in the spectrum.
+
+    Returns:
+    - A list of element symbols identified in the spectrum.
+    """
     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-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-M3' 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
+    energy_scale = spectrum.get_spectral_dims(return_axis=True)[0].values
+    element_list = set()
+    peaks = minor_peaks[np.argsort(spectrum[minor_peaks])]
+    accounted_peaks = set()
+    for i, peak in reversed(list(enumerate(peaks))):
+        for z in range(5, 82):
+            if i in accounted_peaks:
+                continue
+            edge_info  = pyTEMlib.eels_tools.get_x_sections(z)
+            # element = edge_info['name']
+            lines = edge_info.get('lines', {})
+            if abs(lines.get('K-L3', {}).get('position', 0) - energy_scale[peak]) <40:
+                element_list.add(edge_info['name'])
+                for key, line in lines.items():
+                    dist = np.abs(energy_scale[peaks]-line.get('position', 0))
+                    if key[0] == 'K' and np.min(dist)< 40:
+                        ind = np.argmin(dist)
+                        accounted_peaks.add(ind)
+            # This is a special case for boron and carbon
+            elif abs(lines.get('K-L2', {}).get('position', 0) - energy_scale[peak]) <30:
+                accounted_peaks.add(i)
+                element_list.add(edge_info['name'])
+
+            if abs(lines.get('L3-M5', {}).get('position', 0) - energy_scale[peak]) <50:
+                element_list.add(edge_info['name'])
+                for key, line in edge_info['lines'].items():
+                    dist = np.abs(energy_scale[peaks]-line.get('position', 0))
+                    if key[0] == 'L' and np.min(dist)< 40 and line['weight'] > 0.01:
+                        ind = np.argmin(dist)
+                        accounted_peaks.add(ind)
+    return list(element_list)
+
+
+def get_x_ray_lines(spectrum, element_list):
+    """
+    Analyze the given spectrum to identify and characterize the X-ray emission lines
+    associated with the specified elements.
+
+    Parameters:
+    - spectrum: A sidpy.Dataset object containing the spectral data.
+    - elements: A list of element symbols (e.g., ['Fe', 'Cu']) to look for in the spectrum.
+
+    Returns:
+    - A dictionary where each key is an element symbol and each value is another dictionary
+      containing information about the X-ray lines detected for that element.
+    
+    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
+    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 = np.array(spectrum.get_spectral_dims(return_axis=True)[0].values)
-    for element in elements:
+    # omega_L = Z**4/(alpha_l+Z**4)
+    # omega_M = Z**4/(alpha_m+Z**4)
+    """
+
+    out_tags = {}
+    x_sections = pyTEMlib.xrpa_x_sections.x_sections
+    energy_scale = spectrum.get_spectral_dims(return_axis=True)[0].values
+    for element in element_list:
         atomic_number = pyTEMlib.eds_tools.elements_list.index(element)
         out_tags[element] ={'Z': atomic_number}
-        lines = x_sections[str(atomic_number)]['lines']
-        K_weight = 0
-        K_main = 'None'
-        K_lines = []
-        L_weight = 0
-        L_main = 'None'
-        L_lines = []
-        M_weight = 0
-        M_main = 'None'
-        M_lines = []
-        
+        lines = pyTEMlib.xrpa_x_sections.x_sections.get(str(atomic_number), {}).get('lines', {})
+        if not lines:
+            break
+        k_weight = 0
+        k_main = 'None'
+        k_lines = []
+        l_weight = 0
+        l_main = 'None'
+        l_lines = []
+        m_weight = 0
+        m_main = 'None'
+        m_lines  = []
+
         for key, line in lines.items():
             if 'K' == key[0]:
                 if line['position'] < energy_scale[-1]:
-                        K_lines.append(key)
-                        if line['weight'] > K_weight:
-                            K_weight = line['weight']
-                            K_main = key
+                    k_lines.append(key)
+                    if line['weight'] > k_weight:
+                        k_weight = line['weight']
+                        k_main = key
             if 'L' == key[0]:
                 if line['position'] < energy_scale[-1]:
-                        L_lines.append(key)
-                        if line['weight'] > L_weight:
-                            L_weight = line['weight']
-                            L_main = key
+                    l_lines.append(key)
+                    if line['weight'] > l_weight:
+                        l_weight = line['weight']
+                        l_main = key
             if 'M' == key[0]:
                 if line['position'] < energy_scale[-1]:
-                        M_lines.append(key)
-                        if line['weight'] > M_weight:
-                            M_weight = line['weight']
-                            M_main = key
-            
-        if K_weight > 0:
-            out_tags[element]['K-family'] = {'main': K_main, 'weight': K_weight, 'lines': K_lines}
-            height = spectrum[np.searchsorted(energy_scale, x_sections[str(atomic_number)]['lines'][K_main]['position'] )].compute()
-            out_tags[element]['K-family']['height'] = height/K_weight
-            for key in K_lines:
+                    m_lines .append(key)
+                    if line['weight'] > m_weight:
+                        m_weight = line['weight']
+                        m_main = key
+        if k_weight > 0:
+            out_tags[element]['K-family'] = {'main': k_main, 'weight': k_weight, 'lines': k_lines}
+            position = x_sections[str(atomic_number)]['lines'][k_main]['position']
+            height = spectrum[np.searchsorted(energy_scale, position)].compute()
+            out_tags[element]['K-family']['height'] = height/k_weight
+            for key in k_lines:
                 out_tags[element]['K-family'][key] = x_sections[str(atomic_number)]['lines'][key]
-        if L_weight > 0:     
-            out_tags[element]['L-family'] = {'main': L_main, 'weight': L_weight, 'lines': L_lines}
-            height = spectrum[np.searchsorted(energy_scale, x_sections[str(atomic_number)]['lines'][L_main]['position'] )].compute()
-            out_tags[element]['L-family']['height'] = height/L_weight
-            for key in L_lines:
+        if l_weight > 0:
+            out_tags[element]['L-family'] = {'main': l_main, 'weight': l_weight, 'lines': l_lines}
+            position = x_sections[str(atomic_number)]['lines'][l_main]['position']
+            height = spectrum[np.searchsorted(energy_scale, position)].compute()
+            out_tags[element]['L-family']['height'] = height/l_weight
+            for key in l_lines:
                 out_tags[element]['L-family'][key] = x_sections[str(atomic_number)]['lines'][key]
-        if M_weight > 0:
-            out_tags[element]['M-family'] = {'main': M_main, 'weight': M_weight, 'lines': M_lines}
-            height = spectrum[np.searchsorted(energy_scale, x_sections[str(atomic_number)]['lines'][M_main]['position'] )].compute()
-            out_tags[element]['M-family']['height'] = height/M_weight
-            for key in M_lines:
+        if m_weight > 0:
+            out_tags[element]['M-family'] = {'main': m_main, 'weight': m_weight, 'lines': m_lines }
+            position = x_sections[str(atomic_number)]['lines'][m_main]['position']
+            height = spectrum[np.searchsorted(energy_scale, position)].compute()
+            out_tags[element]['M-family']['height'] = height/m_weight
+            for key in m_lines :
                 out_tags[element]['M-family'][key] = x_sections[str(atomic_number)]['lines'][key]
-
-        xs = get_eds_cross_sections(atomic_number)
-        if 'K' in xs and 'K-family' in out_tags[element]:
-            out_tags[element]['K-family']['probability'] = xs['K']
-        if 'L' in xs and 'L-family' in out_tags[element]:
-            out_tags[element]['L-family']['probability'] = xs['L']
-        if 'M' in xs and 'M-family' in out_tags[element]:
-            out_tags[element]['M-family']['probability'] = xs['M']
-
-    if 'EDS' not in spectrum.metadata:
-        spectrum.metadata['EDS'] = {}
-    spectrum.metadata['EDS'].update(out_tags)
+    spectrum.metadata.setdefault('EDS', {}).update(out_tags)
     return out_tags
 
 
-def getFWHM(E, E_ref, FWHM_ref):
-    return np.sqrt(2.5*(E-E_ref)+FWHM_ref**2)
+def get_fwhm(energy: float, energy_ref: float, fwhm_ref: float) -> float:
+    """ Calculate FWHM of Gaussians"""
+    return np.sqrt(2.5*(energy-energy_ref)+fwhm_ref**2)
+
+
+def gaussian(energy_scale: np.ndarray, mu: float, fwhm: float) -> np.ndarray:
+    """ Gaussian function"""
+    sig = fwhm/2/np.sqrt(2*np.log(2))
+    return np.exp(-np.power(np.array(energy_scale) - mu, 2.) / (2 * np.power(sig, 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)
+def get_peak(energy: float, energy_scale: np.ndarray,
+             energy_ref: float = 5895.0, fwhm_ref: float = 136) -> np.ndarray:
+    """ Generate a normalized Gaussian peak for a given energy."""
+    # all energies in eV
+    fwhm  = get_fwhm(energy, energy_ref, fwhm_ref)
+    gauss = gaussian(energy_scale, energy, fwhm)
 
-    return gaus /(gaus.sum()+1e-12)
+    return gauss /(gauss.sum()+1e-12)
 
 
 def initial_model_parameter(spectrum):
+    """ Initialize model parameters based on the spectrum's metadata.""" 
     tags = spectrum.metadata['EDS']
     energy_scale = spectrum.get_spectral_dims(return_axis=True)[0]
     p = []
@@ -302,7 +348,7 @@ def initial_model_parameter(spectrum):
                 if line[0] == 'K':
                     model += get_peak(info['position'], energy_scale)*info['weight']
             lines['K-family']['peaks'] = model  /model.sum()  # *lines['K-family']['probability']
-             
+
             p.append(lines['K-family']['height'] / lines['K-family']['peaks'].max())
             peaks.append(lines['K-family']['peaks'])
             keys.append(element+':K-family')
@@ -325,90 +371,109 @@ def initial_model_parameter(spectrum):
             peaks.append(lines['M-family']['peaks'])
             keys.append(element+':M-family')
 
-
-    #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):
-    model = np.zeros(len(spectrum))
+def get_model(spectrum):
+    """
+    Construct the model spectrum from the metadata in the given spectrum object.
+
+    Parameters:
+    - spectrum: The spectrum object containing metadata and spectral data.
+
+    Returns:
+    - model: The constructed model spectrum as a numpy array.
+    """
+    model = np.zeros(len(np.array(spectrum)))
     for key in spectrum.metadata['EDS']:
-        for family in spectrum.metadata['EDS'][key]:
-            if isinstance(spectrum.metadata['EDS'][key][family], dict):
-                intensity  = spectrum.metadata['EDS'][key][family]['areal_density']
-                peaks = spectrum.metadata['EDS'][key][family]['peaks']
-                model += peaks * intensity
+        if isinstance(spectrum.metadata['EDS'][key], dict) and key in elements_list:
+            for family in spectrum.metadata['EDS'][key]:
+                if '-family' in family:
+                    intensity  = spectrum.metadata['EDS'][key][family].get('areal_density', 0)
+                    peaks = spectrum.metadata['EDS'][key][family].get('peaks', np.zeros(len(model)))
+                    if peaks.sum() <0.1:
+                        print('no intensity',key, family)
+                    model += peaks * intensity
 
     if 'detector_efficiency' in spectrum.metadata['EDS']['detector'].keys():
         detector_efficiency = spectrum.metadata['EDS']['detector']['detector_efficiency']
     else:
         detector_efficiency = None
-    E_0 = spectrum.metadata['experiment']['acceleration_voltage']
-
-    # 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)
+    e_0 = spectrum.metadata['experiment']['acceleration_voltage']
+    pp = spectrum.metadata['EDS']['bremsstrahlung']
+    energy_scale = spectrum.get_spectral_dims(return_axis=True)[0].values
 
+    if detector_efficiency is not None:
+        bremsstrahlung = (pp[-3] + pp[-2] * (e_0 - energy_scale) / energy_scale +
+                          pp[-1] * (e_0 - energy_scale) ** 2 / energy_scale)
+        model += bremsstrahlung
+        model *= detector_efficiency
     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)
+def fit_model(spectrum, use_detector_efficiency=False):
+    """
+    Fit the EDS spectrum using a model composed of elemental peaks and bremsstrahlung background.
+
+    Parameters:
+    - spectrum: The EDS spectrum to fit.
+    - elements: List of elements to consider in the fit.
+    - use_detector_efficiency: Whether to include detector efficiency in the model.
+
+    Returns:
+    - peaks: The fitted peak shapes.
+    - p: The fitted parameters.
+    """
+    peaks, pin, _ = initial_model_parameter(spectrum)
+
     energy_scale = spectrum.get_spectral_dims(return_axis=True)[0].values
-    
+
     if 'detector' in spectrum.metadata['EDS'].keys():
-        if 'start_channel' not in spectrum.metadata['EDS']['detector']:
-            spectrum.metadata['EDS']['detector']['start_channel'] = np.searchsorted(energy_scale, 100)
-        if 'detector_efficiency' in spectrum.metadata['EDS']['detector'].keys():
-            if use_detector_efficiency:
-                detector_efficiency = spectrum.metadata['EDS']['detector']['detector_efficiency']
+        start = spectrum.metadata['EDS'].get('detector', {}).get('start_channel', 120)
+        spectrum.metadata['EDS']['detector']['start_channel'] = np.searchsorted(energy_scale, start)
+        if use_detector_efficiency:
+            efficiency = spectrum.metadata['EDS']['detector'].get('detector_efficiency', [])
+            if not isinstance(efficiency, (list, np.ndarray)):
+                if len(efficiency) != len(spectrum):
+                    efficiency = detector_response(spectrum)
         else:
             use_detector_efficiency = False
     else:
         print('need detector information to fit spectrum')
-        return
-    start = spectrum.metadata['EDS']['detector']['start_channel']
-    energy_scale = energy_scale[start:]
+        return None, None
 
-    E_0= spectrum.metadata['experiment']['acceleration_voltage']
+    e_0 = spectrum.metadata.get('experiment', {}).get('acceleration_voltage', 0.)
 
     def residuals(pp, yy):
-        #get_model(peaks, pp, detector_efficiency=None)
+        """ residuals for fit"""
         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)
-
+            bremsstrahlung = (pp[-3] + pp[-2] * (e_0 - energy_scale) / energy_scale +
+                              pp[-1] * (e_0 - energy_scale)**2 / energy_scale)
+            model += bremsstrahlung
+            model *= efficiency
+        err = np.abs(yy - model)  # /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, peaks, p)
-
-
-    if 'EDS' not in spectrum.metadata:
-        spectrum.metadata['EDS'] = {}
-    spectrum.metadata['EDS'].update(out_tags)
+    [p, _] = scipy.optimize.leastsq(residuals, pin, args=(y,), maxfev=10000)
 
+    update_fit_values(spectrum.metadata['EDS'], peaks, p)
     return np.array(peaks), np.array(p)
 
 
 def update_fit_values(out_tags, peaks, p):
+    """
+    Update the out_tags dictionary with the fitted peak shapes and parameters.
+
+    Parameters:
+    - out_tags: Dictionary containing the initial tags for each element and line family.
+    - peaks: Array of fitted peak shapes.
+    - p: Array of fitted parameters.
+    """
     index = 0
-    for element, lines in out_tags.items():
+    for lines in out_tags.values():
         if 'K-family' in lines:
             lines['K-family']['areal_density'] = p[index]
             lines['K-family']['peaks'] = peaks[index]
@@ -421,129 +486,51 @@ def update_fit_values(out_tags, peaks, p):
             lines['M-family']['areal_density'] =p[index]
             lines['M-family']['peaks'] = peaks[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
+    out_tags['bremsstrahlung'] = p[-4:]
 
 
-def get_eds_cross_sections(z, acceleration_voltage=200000):
-    energy_scale = np.arange(1,20000)
-    Xsection = pyTEMlib.eels_tools.xsec_xrpa(energy_scale, acceleration_voltage/1000., z, 400.)
-    edge_info = pyTEMlib.eels_tools.get_x_sections(z)
-
-    
-    eds_cross_sections = {}
-    Xyield = edge_info['total_fluorescent_yield']
-    if 'K' in Xyield:
-            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[eds_xsection<0] = 0.
-                start_sum = np.searchsorted(energy_scale, edge_info['K1']['onset'])
-                end_sum = start_sum+600
-                if end_sum> len(Xsection):
-                    end_sum = len(Xsection)-1
-                eds_cross_sections['K1'] = eds_xsection[start_sum:end_sum].sum() 
-                eds_cross_sections['K'] = eds_xsection[start_sum:end_sum].sum() * Xyield['K']
-    
-    if 'L3' in Xyield:
-            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[eds_xsection<0] = 0.
-                start_sum = np.searchsorted(energy_scale, edge_info['L3']['onset'])
-                end_sum = start_sum+600
-                if end_sum> len(Xsection):
-                    end_sum = len(Xsection)-1
-                if end_sum >np.searchsorted(energy_scale, edge_info['K1']['onset'])-10:
-                    end_sum = np.searchsorted(energy_scale, edge_info['K1']['onset'])-10
-                eds_cross_sections['L'] = eds_xsection[start_sum:end_sum].sum() 
-                L1_channel =  np.searchsorted(energy_scale, edge_info['L1']['onset'])
-                m_start = start_sum-100
-                if m_start < 2:
-                    m_start = start_sum-20
-                l3_rise = np.max(Xsection[m_start: L1_channel-10])-np.min(Xsection[m_start: L1_channel-10])
-                l1_rise = np.max(Xsection[L1_channel-10: L1_channel+100])-np.min(Xsection[L1_channel-10: L1_channel+100])
-                l1_ratio = l1_rise/l3_rise
-                
-                eds_cross_sections['L1'] = l1_ratio * eds_cross_sections['L']
-                eds_cross_sections['L2'] = eds_cross_sections['L']*(1-l1_ratio)*1/3
-                eds_cross_sections['L3'] = eds_cross_sections['L']*(1-l1_ratio)*2/3
-                eds_cross_sections['yield_L1'] = Xyield['L1']
-                eds_cross_sections['yield_L2'] = Xyield['L2']
-                eds_cross_sections['yield_L3'] = Xyield['L3']
-
-                eds_cross_sections['L'] = eds_cross_sections['L1']*Xyield['L1']+eds_cross_sections['L2']*Xyield['L2']+eds_cross_sections['L3']*Xyield['L3']
-                # eds_cross_sections['L'] /= 8
-    if 'M5' in Xyield:
-            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[eds_xsection<0] = 0.
-                start_sum = np.searchsorted(energy_scale, edge_info['M5']['onset'])
-                end_sum = start_sum+600
-                if end_sum > np.searchsorted(energy_scale, edge_info['L3']['onset'])-10:
-                    end_sum = np.searchsorted(energy_scale, edge_info['L3']['onset'])-10
-                eds_cross_sections['M'] = eds_xsection[start_sum:end_sum].sum() 
-                #print(edge_info['M5']['onset'] - edge_info['M1']['onset'])
-                M3_channel =  np.searchsorted(energy_scale, edge_info['M3']['onset'])
-                M1_channel =  np.searchsorted(energy_scale, edge_info['M1']['onset'])
-                m5_rise = np.max(Xsection[start_sum-100: M3_channel-10])-np.min(Xsection[start_sum-100: M3_channel-10])
-                m3_rise = np.max(Xsection[M3_channel-10: M1_channel-10])-np.min(Xsection[M3_channel-10: M1_channel-10])
-                m1_rise = np.max(Xsection[M1_channel-10: M1_channel+100])-np.min(Xsection[M1_channel-10: M1_channel+100])
-                m1_ratio = m1_rise/m5_rise
-                m3_ratio = m3_rise/m5_rise
-                m5_ratio = 1-(m1_ratio+m3_ratio)
-                #print(m1_ratio, m3_ratio, 1-(m1_ratio+m3_ratio))
-                eds_cross_sections['M1'] = m1_ratio * eds_cross_sections['M']
-                eds_cross_sections['M2'] = m3_ratio * eds_cross_sections['M']*1/3
-                eds_cross_sections['M3'] = m3_ratio * eds_cross_sections['M']*2/3
-                eds_cross_sections['M4'] = m5_ratio * eds_cross_sections['M']*2/5
-                eds_cross_sections['M5'] = m5_ratio * eds_cross_sections['M']*3/5
-                eds_cross_sections['yield_M1'] = Xyield['M1']
-                eds_cross_sections['yield_M2'] = Xyield['M2']
-                eds_cross_sections['yield_M3'] = Xyield['M3']
-                eds_cross_sections['yield_M4'] = Xyield['M4']
-                eds_cross_sections['yield_M5'] = Xyield['M5']
-                eds_cross_sections['M'] = eds_cross_sections['M1']*Xyield['M1']+eds_cross_sections['M2']*Xyield['M2']+eds_cross_sections['M3']*Xyield['M3'] \
-                                            +eds_cross_sections['M4']*Xyield['M4']+eds_cross_sections['M5']*Xyield['M5']
-                #eds_cross_sections['M'] /= 18
-    return eds_cross_sections
+def get_phases(dataset, mode='kmeans', number_of_phases=4):
+    """
+    Perform phase segmentation on the dataset using the specified clustering mode.
 
+    Parameters:
+    - dataset: The dataset to be segmented.
+    - mode: The clustering mode to use ('kmeans' or other).
+    - number_of_phases: The number of phases (clusters) to identify.
 
-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
+    Returns:
+    None. The results are stored in the dataset's metadata.
+    """
+    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
+        #choose number of components
+        gmm = sklearn.mixture.GaussianMixture(n_components=number_of_phases, covariance_type="full")
 
-        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)
+        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]),
+        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]),
+        km = sklearn.cluster.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):
+    """
+    Plot the phase maps and corresponding spectra from the dataset.
+
+    Parameters:
+    - dataset: The dataset containing phase information.
+    - image: Optional. The image to overlay the phase map on.
+    - survey_image: Optional. A survey image to display alongside the phase maps.
+    """
     if survey_image is not None:
         ncols = 3
     else:
@@ -553,19 +540,17 @@ def plot_phases(dataset, image=None, survey_image=None):
     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']
+
+    if 'kmeans' not in dataset.metadata:
+        raise ValueError('No phase information found, run get_phases first')
+    phase_spectra = dataset.metadata['kmeans']['means']
+    map_data = 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)
-    
+    im = axes[axis_index].imshow(map_data.T, cmap=cmap,vmin=np.min(map_data) - 0.5,
+                          vmax=np.max(map_data) + 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)
@@ -580,30 +565,262 @@ def plot_phases(dataset, image=None, survey_image=None):
 
 
 def plot_lines(eds_quantification: dict, axis: plt.Axes):
+    """
+    Plot EDS line strengths on the given matplotlib axis.
+
+    Parameters:
+    - eds_quantification: A dictionary containing EDS line data.
+    - axis: A matplotlib Axes object where the lines will be plotted.
+    """
+    colors = plt.get_cmap('Dark2').colors # jet(np.linspace(0, 1, 10))
+
+    index = 0
     for key, lines in eds_quantification.items():
+        color = colors[index % len(colors)]
         if 'K-family' in lines:
             intensity = lines['K-family']['height']
             for line in lines['K-family']:
                 if line[0] == 'K':
                     pos = lines['K-family'][line]['position']
-                    axis.plot([pos,pos], [0, intensity*lines['K-family'][line]['weight']], color='blue')  
-                    if line == lines['K-family']['main']:      
-                        axis.text(pos,0, key+'\n'+line, verticalalignment='top')
+                    axis.plot([pos,pos], [0, intensity*lines['K-family'][line]['weight']],
+                              color=color)
+                    if line == lines['K-family']['main']:
+                        axis.text(pos,0, key+'\n'+line, verticalalignment='top', color=color)
 
         if 'L-family' in lines:
             intensity = lines['L-family']['height']
             for line in lines['L-family']:
                 if line[0] == 'L':
                     pos = lines['L-family'][line]['position']
-                    axis.plot([pos,pos], [0, intensity*lines['L-family'][line]['weight']], color='black')    
-                    if line in [lines['L-family']['main'], 'L3-M5', 'L3-N5', 'L1-M3']:            
-                        axis.text(pos,0, key+'\n'+line, verticalalignment='top')
+                    axis.plot([pos,pos], [0, intensity*lines['L-family'][line]['weight']],
+                              color=color)
+                    if line in [lines['L-family']['main'], 'L3-M5', 'L3-N5', 'L1-M3']:
+                        axis.text(pos,0, key+'\n'+line, verticalalignment='top', color=color)
 
         if 'M-family' in lines:
             intensity = lines['M-family']['height']
             for line in lines['M-family']:
                 if line[0] == 'M':
                     pos = lines['M-family'][line]['position']
-                    axis.plot([pos,pos], [0, intensity*lines['M-family'][line]['weight']], color='green')    
-                    if line in [lines['M-family']['main'], 'M5-N7', 'M4-N6']:      
-                        axis.text(pos,0, key+'\n'+line, verticalalignment='top')
+                    axis.plot([pos,pos],
+                              [0, intensity*lines['M-family'][line]['weight']],
+                              color=color)
+                    if line in [lines['M-family']['main'], 'M5-N7', 'M4-N6']:
+                        axis.text(pos,0, key+'\n'+line, verticalalignment='top', color=color)
+
+        index +=1
+        index = index % 10
+
+
+def get_eds_xsection(x_section, energy_scale, start_bgd, end_bgd):
+    """
+    Calculate the EDS cross-section by subtracting the background and zeroing out
+    values outside the specified energy range.
+    The processed cross-section data with background removed 
+    and values outside the energy range set to zero.
+
+    Parameters:
+    - x_section: The raw cross-section data.
+    - energy_scale: The energy scale corresponding to the cross-section data.
+    - start_bgd: The start energy for background calculation.
+    - end_bgd: The end energy for background calculation.
+
+    Returns:
+    - cross_section_core: np.array
+    """
+    background = pyTEMlib.eels_tools.power_law_background(x_section, energy_scale,
+                                                          [start_bgd, end_bgd], verbose=False)
+    cross_section_core = x_section- 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 add_k_factors(element_dict, element, k_factors):
+    """Add k-factors to element dictionary."""
+    family = element_dict.get('K-family', {})
+    line = k_factors.get(element, {}).get('Ka1', False)
+    if not line:
+        line = k_factors.get(element, {}).get('Ka2', False)
+    if line and family:
+        family['k_factor'] = float(line)
+
+        family = element_dict.get('L-family', False)
+        line = k_factors.get(element, {}).get('La1', False)
+        if line and family:
+            family['k_factor'] = float(line)
+
+        family = element_dict.get('M-family', False)
+        line = k_factors.get(element, {}).get('Ma1', False)
+        if line and family:
+            family['k_factor'] = float(line)
+
+
+def quantify_EDS(spectrum, quantification_dict=None, mask=['Cu'] ):
+    """Calculate quantification for EDS spectrum with either k-factors or cross sections."""
+
+    for key in spectrum.metadata['EDS']:
+        element = 0
+        if isinstance(spectrum.metadata['EDS'][key], dict) and key in elements_list:
+            element = spectrum.metadata['EDS'][key].get('Z', 0)
+        if element < 1:
+            continue
+        if quantification_dict is None:
+            quantification_dict = {}
+
+        edge_info = pyTEMlib.eels_tools.get_x_sections(element)
+        spectrum.metadata['EDS'][key]['atomic_weight'] = edge_info['atomic_weight']
+        spectrum.metadata['EDS'][key]['nominal_density'] = edge_info['nominal_density']
+
+        for family, item in edge_info['fluorescent_yield'].items():
+            spectrum.metadata['EDS'][key][f"{family}-family"
+                                          ]['fluorescent_yield'] = item
+        if quantification_dict.get('metadata', {}).get('type', '') == 'k_factor':
+            k_factors = quantification_dict.get('table', {})
+            add_k_factors(spectrum.metadata['EDS'][key], key, k_factors)
+
+    if quantification_dict is None:
+        print('using cross sections for quantification')
+        quantify_cross_section(spectrum, None, mask=mask)
+    elif not isinstance(quantification_dict, dict):
+        pass
+    elif quantification_dict.get('metadata', {}).get('type', '') == 'k_factor':
+        print('using k-factors for quantification')
+        quantification_k_factors(spectrum, mask=mask)  # , quantification_dict['table'],
+    elif quantification_dict.get('metadata', {}).get('type', '') == 'cross_section':
+        print('using cross sections for quantification')
+        quantify_cross_section(spectrum, quantification_dict['table'], mask=mask)
+    else:
+        print('using cross sections for quantification')
+        quantify_cross_section(spectrum, None, mask=mask)
+        # print('Need either k-factor or cross section dictionary')
+
+
+def read_esl_k_factors(filename, reduced=False):
+    """ Read k-factors from esl file."""
+    k_factors = {}
+    if not os.path.isfile(filename):
+        print('k-factor file not found', filename)
+        return None, 'k_factors_Bruker_15keV.json'
+    tree = xml.etree.ElementTree.parse(filename)
+    root = tree.getroot()
+    k_dict = pyTEMlib.file_reader.etree_to_dict(root)
+    k_dict = k_dict.get('TRTStandardLibrary', {})
+    k_factor_dict = (k_dict.get('ClassInstance', {}).get('CliffLorimerFactors', {}))
+    for index, item in enumerate(k_factor_dict.get('K_Factors', '').split(',')):
+        if index < 84:
+            if item.strip() != '0':
+                k_factors[elements[index]] = {'Ka1': float(item)}
+            else:
+                k_factors[elements[index]] = {}
+    for index, item in enumerate(k_factor_dict.get('L_Factors', '').split(',')):
+        if index < 84:
+            if item.strip() != '0':
+                k_factors[elements[index]]['La1'] =  float(item)
+    for index, item in enumerate(k_factor_dict.get('M_Factors', '').split(',')):
+        if index < 84:
+            if item.strip() != '0':
+                k_factors[elements[index]]['Ma1'] =  float(item)
+    primary = int(float(k_dict.get('ClassInstance', {}).get('Header', {}).get('PrimaryEnergy', 0)))
+    name = f'k_factors_Bruker_{primary}keV.json'
+    metadata = {'origin': 'pyTEMlib',
+                'source_file': filename,
+                'reduced': reduced,
+                'version': pyTEMlib.__version__,
+                'type': 'k-factors',
+                'spectroscopy': 'EDS',
+                'acceleration_voltage': primary,
+                'microscope': 'Bruker',
+                'name': name}
+    return k_factors, metadata
+
+
+def read_csv_k_factors(filename, reduced=True):
+    """ Read k-factors from csv file of ThermoFisher TEMs."""
+    k_factors = {}
+    with open(filename, newline='', encoding='utf-8') as csvfile:
+        reader = csv.reader(csvfile, delimiter=',', quotechar='|')
+        start = True
+        for row in reader:
+            if start:
+                k_column = row.index('K-factor')
+                start = False
+            else:
+                element, line = row[0].split('-')
+                if element not in k_factors:
+                    k_factors[element] = {}
+                if reduced:
+                    if line[-1:] == '1':
+                        k_factors[element][line] = row[k_column]
+                else:
+                    k_factors[element][line] = row[k_column]
+    metadata = {'origin': 'pyTEMlib',
+                'source_file': filename,
+                'reduced': reduced,
+                'microscope': 'ThermoFisher', 
+                'acceleration_voltage': 200000,
+                'version': pyTEMlib.__version__,
+                'type': 'k-factors',
+                'spectroscopy': 'EDS',
+                'name': 'k_factors_Thermo_200keV.json'}
+    return k_factors, metadata
+
+
+def convert_k_factor_file(file_name, reduced=True, new_name=None):
+    """ Convert k-factor file to a dictionary."""
+    if not os.path.isfile(file_name):
+        print('k-factor file not found', file_name)
+        return None
+    _, filename = os.path.split(file_name)
+    _, extension = os.path.splitext(filename)
+    if extension == '.csv':
+        k_factors, metadata = read_csv_k_factors(file_name, reduced=reduced)
+    elif extension == '.esl':
+        k_factors, metadata = read_esl_k_factors(file_name)
+    else:
+        print('unknown k-factor file format', extension)
+        return None
+    if new_name is None:
+        new_name = metadata['name']
+    write_k_factors(k_factors, metadata, file_name=new_name)
+    return k_factors, metadata
+
+
+def get_k_factor_files():
+    """ Get list of k-factor files in the .pyTEMlib folder."""
+    k_factor_files = []
+    for file_name in os.listdir(config_path):
+        if 'k_factors' in file_name:
+            k_factor_files.append(file_name)
+    return k_factor_files
+
+
+def write_k_factors(k_factors, metadata, file_name='k_factors.json'):
+    """ Write k-factors to a json file."""
+    file_name = os.path.join(config_path, file_name)
+    save_dict = {"table" : k_factors, "metadata" : metadata}
+    with open(file_name, "w", encoding='utf-8') as json_file:
+        json.dump(save_dict, json_file, indent=4, encoding='utf-8')
+
+
+def read_k_factors(file_name='k_factors.json'):
+    """ Read k-factors from a json file."""
+    if not os.path.isfile(os.path.join(config_path, file_name)):
+        print('k-factor file not found', file_name)
+        return None
+    with open(os.path.join(config_path, file_name), 'r', encoding='utf-8') as json_file:
+        table, metadata = json.load(json_file)
+    return table, metadata
+
+
+def load_k_factors(reduced=True):
+    """ Load k-factors from csv files in the .pyTEMlib folder."""
+    k_factors = {}
+    metadata = {}
+    data_path = os.path.join(os.path.expanduser('~'), '.pyTEMlib')
+    for file_name in os.listdir(data_path):
+        if 'k-factors' in file_name:
+            path = os.path.join(data_path, file_name)
+            k_factors, metadata = read_csv_k_factors(path, reduced=reduced)
+            metadata['type'] = 'k_factor'
+    return {'table': k_factors, 'metadata': metadata}