DiadFit 0.0.81__py3-none-any.whl → 0.0.84__py3-none-any.whl

DiadFit/ne_lines.py

@@ -19,6 +19,8 @@ import scipy.stats as stats
 import pickle
 
 
+allowed_models = ["VoigtModel", "PseudoVoigtModel", "Pearson4Model", "SkewedVoigtModel"]
+
 
 
 encode="ISO-8859-1"
@@ -73,12 +75,16 @@ def calculate_Ne_splitting(wavelength=532.05, line1_shift=1117, line2_shift=1447
 
     closest1=find_closest(df_Ne, line1_shift).loc['Raman_shift (cm-1)']
     closest2=find_closest(df_Ne, line2_shift).loc['Raman_shift (cm-1)']
+    closest_1_int=find_closest(df_Ne, line1_shift).loc['Intensity']
+    closest_2_int=find_closest(df_Ne, line2_shift).loc['Intensity']
 
     diff=abs(closest1-closest2)
 
     df=pd.DataFrame(data={'Ne_Split': diff,
     'Line_1': closest1,
     'Line_2': closest2,
+    'Line_1_int': closest_1_int,
+    'Line_2_int': closest_2_int,
     'Entered Pos Line 1': line1_shift,
     'Entered Pos Line 2': line2_shift}, index=[0])
 
@@ -109,88 +115,229 @@ def calculate_Ne_line_positions(wavelength=532.05, cut_off_intensity=2000):
     Ne_emission_line_air=np.array([
     
     
-541.85584,
-542.009,
-542.0155,
-543.36513,
-544.7120,
-
-544.85091,
-549.44158,
-550.73442,
-551.1176,
-551.1485,
-
-552.063,
-553.36788,
-553.86510,
-555.90978,
-556.24416,
-
-556.27662,
-556.30531,
-    
-    
-    
-556.244160,
-556.276620,
-556.305310,
-557.603940,
-558.590500,
-558.934720,
-559.115000,
-565.256640,
-565.602580,
-565.665880,
-566.220000,
-566.254890,
-568.464700,
-568.981630,
-571.534090,
-571.887980,
-571.922480,
-571.953000,
-574.243700,
-574.829850,
-574.864460,
-576.058850,
-576.405250,
-576.441880,
-577.030670,
-580.409000,
-580.444960,
-581.140660,
-581.662190,
-582.015580,
-582.890630
-
-
-
+    541.85584,
+    542.009,
+    542.0155,
+    543.36513,
+    544.7120,
+    
+    544.85091,
+    549.44158,
+    550.73442,
+    551.1176,
+    551.1485,
+    
+    552.063,
+    553.36788,
+    553.86510,
+    555.90978,
+    556.24416,
+    
+    556.27662,
+    556.30531,
+    
+    
+    
+    556.244160,
+    556.276620,
+    556.305310,
+    557.603940,
+    558.590500,
+    558.934720,
+    559.115000,
+    565.256640,
+    565.602580,
+    565.665880,
+    566.220000,
+    566.254890,
+    568.464700,
+    568.981630,
+    571.534090,
+    571.887980,
+    571.922480,
+    571.953000,
+    574.243700,
+    574.829850,
+    574.864460,
+    576.058850,
+    576.405250,
+    576.441880,
+    577.030670,
+    580.409000,
+    580.444960,
+    581.140660,
+    581.662190,
+    582.015580,
+    582.890630,
+    585.24878,
+    586.84165,
+    587.2145,
+    587.28275,
+    588.1895,
+    589.83287,
+    590.20944,
+    590.24623,
+    590.27835,
+    590.64294,
+    591.3633,
+    591.89068,
+    591.9029,
+    593.44522,
+    593.93154,
+    594.4834,
+    596.16228,
+    596.5471,
+    596.6179,
+    597.46273,
+    597.55343,
+    598.23753,
+    598.79074,
+    599.16477,
+    600.09275,
+    602.99968,
+    604.2013,
+    604.61348,
+    606.45359,
+    607.43376,
+    609.6163,
+    611.088,
+    611.272,
+    611.80187,
+    612.84498,
+    613.277,
+    614.2508,
+    614.30627,
+    615.02985,
+    615.6138,
+    616.35937,
+    616.609,
+    617.28156,
+    617.48829,
+    617.52842,
+    618.2146,
+    618.31575,
+    618.90649,
+    619.30663,
+    620.2974,
+    620.57775,
+    620.908,
+    621.018,
+    621.38758,
+    621.72812,
+    622.448,
+    622.5735,
+    623.9032,
+    624.67294,
+    624.9593,
+    625.0925,
+    625.2732,
+    625.2905,
+    625.869,
+    625.87884,
+    626.64952,
+    627.0131,
+    627.242,
+    627.30141,
+    627.60327,
+    627.75,
+    628.358,
+    628.959,
+    629.37447,
+    629.784,
+    630.47893,
+    630.6113,
+    630.766,
+    631.36855,
+    632.1116,
+    632.81646,
+    633.08894,
+    633.44276,
+    634.5653,
+    635.18532,
+    636.49963,
+    638.29914,
+    640.1076,
+    640.2248,
+    640.658,
+    640.97469,
+    642.17044,
+    644.47118,
+    650.65277,
+    651.0877,
+    651.1789,
+    651.6789,
+    651.7041,
+    652.5584,
+    652.603,
+    653.28824,
+    653.8685,
+    653.9143,
+    653.9492,
+    653.9692,
+    655.0653,
+    655.0653,
+    655.9024,
+    655.9285,
+    657.13,
+    657.17,
+    659.89528,
+    660.29007,
+    664.00095,
+    664.08,
+    665.20925,
+    666.6892,
+    667.82766,
+    671.7043,
+    672.11342,
+    673.8032,
+    675.95821,
+    688.694,
+    689.541,
+    692.94672,
+    702.405,
+    703.24128,
+    705.12922,
+    705.91079,
+    706.4762,
+    706.7724,
+    711.23075,
+    713.336,
+    713.854,
+    717.3938,
+    721.321,
+    723.51978,
+    724.51665
+    
+    
+    
+    
+    
+    
     ])
-
+    
     Intensity=np.array([
     
-1500,
-12	,
-500,
-2500,
-80,
-
-1500,
-500,
-250,
-30,
-150,
-
-30,
-750,
-500,
-350,
-1500,
-
-5000,
-750,
-
+    1500,
+    12,
+    500,
+    2500,
+    80,
+    
+    1500,
+    500,
+    250,
+    30,
+    150,
+    
+    30,
+    750,
+    500,
+    350,
+    1500,
+    
+    5000,
+    750,
+    
     
     
     
@@ -225,7 +372,149 @@ def calculate_Ne_line_positions(wavelength=532.05, cut_off_intensity=2000):
     3000.00,
     500.00,
     5000.00,
-    750.00])
+    750.00,
+    
+    20000,
+    750,
+    750,
+    5000,
+    10000,
+    200,
+    30,
+    500,
+    50,
+    500,
+    2500,
+    2500,
+    80,
+    750,
+    500,
+    5000,
+    700,
+    5000,
+    350,
+    5000,
+    6000,
+    80,
+    1500,
+    750,
+    1000,
+    10000,
+    150,
+    500,
+    500,
+    10000,
+    3000,
+    100,
+    160,
+    150,
+    1000,
+    100,
+    1000,
+    10000,
+    1000,
+    500,
+    10000,
+    80,
+    150,
+    700,
+    500,
+    1500,
+    50,
+    700,
+    500,
+    150,
+    1000,
+    70,
+    70,
+    1500,
+    10000,
+    160,
+    500,
+    120,
+    1000,
+    50,
+    120,
+    20,
+    80,
+    180,
+    1000,
+    10000,
+    80,
+    140,
+    700,
+    500,
+    30,
+    30,
+    30,
+    1000,
+    80,
+    1000,
+    100,
+    180,
+    1500,
+    60,
+    3000,
+    1500,
+    10000,
+    60,
+    1000,
+    1000,
+    10000,
+    1000,
+    20000,
+    90,
+    1500,
+    1000,
+    1500,
+    15000,
+    60,
+    140,
+    120,
+    100,
+    22,
+    120,
+    1000,
+    80,
+    120,
+    140,
+    60,
+    140,
+    140,
+    100,
+    100,
+    22,
+    60,
+    10000,
+    1000,
+    100,
+    50,
+    1500,
+    1000,
+    5000,
+    700,
+    20,
+    700,
+    150,
+    70,
+    100,
+    100000,
+    34000,
+    85000,
+    2200,
+    10000,
+    80,
+    80,
+    110,
+    40,
+    55,
+    77000,
+    300,
+    300,
+    77000
+    
+    
+    ])
 
 
 
@@ -236,7 +525,9 @@ def calculate_Ne_line_positions(wavelength=532.05, cut_off_intensity=2000):
                             'Ne emission line in air': Ne_emission_line_air})
 
     df_Ne_r=df_Ne.loc[df_Ne['Intensity']>cut_off_intensity]
-    return df_Ne_r
+    # Lets also only return positive numbers
+    df_Ne_p=df_Ne_r.loc[df_Ne_r['Raman_shift (cm-1)']>0]
+    return df_Ne_p
 
 
 @dataclass
@@ -500,7 +791,7 @@ Ne_array=None):
 
 
 ## Ne baselines
-def remove_Ne_baseline_pk1(Ne, N_poly_pk1_baseline=None, Ne_center_1=None,
+def remove_Ne_baseline_pk(Ne, N_poly_pk1_baseline=None, Ne_center_1=None,
 lower_bck=None, upper_bck1=None, upper_bck2=None, sigma_baseline=None):
     """ This function uses a defined range of values to fit a baseline of Nth degree polynomial to the baseline
     around a specified peak
@@ -582,97 +873,10 @@ lower_bck=None, upper_bck1=None, upper_bck2=None, sigma_baseline=None):
 
     return y_corr, Py_base, x,  Ne_short, Py_base, Baseline_y, Baseline_x
 
-def remove_Ne_baseline_pk2(Ne, N_poly_pk2_baseline=None, Ne_center_2=None, sigma_baseline=None,
-lower_bck=None, upper_bck1=None, upper_bck2=None):
-
-    """ This function uses a defined range of values to fit a baseline of Nth degree polynomial to the baseline
-    around a second selected peak
-
-    Parameters
-    -----------
-
-    Ne: np.array
-        np.array of x and y coordinates from the spectra
-
-    N_poly_pk1_baseline: int
-        Degree of polynomial used to fit the background
-
-    Ne_center_1: float
-        Center position for Ne line being fitted
-
-    lower_bck: list (length 2) Default [-44.2, -22]
-        position used for lower background relative to peak, so =[-50, -20] takes a
-        background -50 and -20 from the peak center
-
-    upper_bck1: list (length 2). Default [15, 50]
-        position used for 1st upper background relative to peak, so =[8, 15] takes a
-        background +8 and +15 from the peak center
-
-    upper_bck2: list (length 2) Default [50, 51]
-        position used for 2nd upper background relative to peak, so =[30, 50] takes a
-        background +30 and +50 from the peak center
-
-    Returns
-    -----------
-    y_corr, Py_base, x,  Ne_short, Py_base, Baseline_y, Baseline_x
-
-    y_corr (numpy.ndarray): The corrected y-values after subtracting the fitted polynomial baseline from the original data.
-    Py_base (numpy.ndarray): The y-values of the fitted polynomial baseline.
-    x (numpy.ndarray): The x-values of the trimmed data within the specified range.
-    Ne_short (numpy.ndarray): The trimmed data within the specified range.
-    Baseline_y (numpy.ndarray): The y-values of the baseline data points.
-    Baseline_x (numpy.ndarray): The x-values of the baseline data points.
-
-    
-    """
-
-
-
-    lower_0baseline_pk2=Ne_center_2+lower_bck[0]
-    upper_0baseline_pk2=Ne_center_2+lower_bck[1]
-    lower_1baseline_pk2=Ne_center_2+upper_bck1[0]
-    upper_1baseline_pk2=Ne_center_2+upper_bck1[1]
-    lower_2baseline_pk2=Ne_center_2+upper_bck2[0]
-    upper_2baseline_pk2=Ne_center_2+upper_bck2[1]
-
-    # Trim for entire range
-    Ne_short=Ne[ (Ne[:,0]>lower_0baseline_pk2) & (Ne[:,0]<upper_2baseline_pk2) ]
-
-    # Get actual baseline
-    Baseline_with_outl=Ne_short[
-    ((Ne_short[:, 0]<upper_0baseline_pk2) &(Ne_short[:, 0]>lower_0baseline_pk2))
-    |
-    ((Ne_short[:, 0]<upper_1baseline_pk2) &(Ne_short[:, 0]>lower_1baseline_pk2))
-    |
-    ((Ne_short[:, 0]<upper_2baseline_pk2) &(Ne_short[:, 0]>lower_2baseline_pk2))]
-
-    # Calculates the median for the baseline and the standard deviation
-    Median_Baseline=np.median(Baseline_with_outl[:, 1])
-    Std_Baseline=np.std(Baseline_with_outl[:, 1])
-
-    # Removes any points in the baseline outside of 2 sigma (helps remove cosmic rays etc).
-    Baseline=Baseline_with_outl[(Baseline_with_outl[:, 1]<Median_Baseline+sigma_baseline*Std_Baseline)
-                                &
-                                (Baseline_with_outl[:, 1]>Median_Baseline-sigma_baseline*Std_Baseline)
-                               ]
-
-    # Fits a polynomial to the baseline of degree
-    Pf_baseline = np.poly1d(np.polyfit(Baseline[:, 0], Baseline[:, 1], N_poly_pk2_baseline))
-    Py_base =Pf_baseline(Ne_short[:, 0])
-    Baseline_ysub=Pf_baseline(Baseline[:, 0])
-    Baseline_x=Baseline[:, 0]
-    Baseline_y=Baseline[:, 1]
-    y_corr= Ne_short[:, 1]-  Py_base
-    x=Ne_short[:, 0]
-
-
-    return y_corr, Py_base, x,  Ne_short, Py_base, Baseline_y, Baseline_x
-
 
 
 
-
-def fit_pk1(x, y_corr, x_span=[-10, 8], Ne_center=1117.1, amplitude=98.1, pk1_sigma=0.28,
+def fit_Ne_pk(x, y_corr, x_span=[-10, 8], Ne_center=1117.1, amplitude=98.1, pk1_sigma=0.28,
 LH_offset_mini=[1.5, 3], peaks_pk1=2, model_name='PseudoVoigtModel', block_print=True,
 const_params=True, spec_res=0.4) :
     """ This function fits the 1117 Ne line as 1 or two voigt peaks
@@ -738,16 +942,12 @@ const_params=True, spec_res=0.4) :
     if peaks_pk1>1:
 
         # Setting up lmfit
-        if model_name == 'PseudoVoigtModel':
-            model0 = PseudoVoigtModel(prefix='p0_')#+ ConstantModel(prefix='c0')
-        if model_name=="VoigtModel":
-            model0 = VoigtModel(prefix='p0_')#+ ConstantModel(prefix='c0')
-        if model_name=='SkewedVoigtModel':
-            model0=SkewedVoigtModel(prefix='p0_')
+        model0 = globals()[model_name](prefix='p0_')
+
         
         pars0 = model0.make_params()
         pars0['p0_center'].set(Ne_center, min=Ne_center-2*spec_res, max=Ne_center+2*spec_res)
-        pars0['p0_amplitude'].set(amplitude)
+        pars0['p0_amplitude'].set(amplitude, min=amplitude*min_off, max=amplitude*max_off)
        
         
         
@@ -763,26 +963,7 @@ const_params=True, spec_res=0.4) :
             print('first iteration, peak Amplitude='+str(np.round(Amp_p0, 4)))
         fwhm_p0=result0.params.get('p0_fwhm')
 
-
-
-        pattern = r"\+/-\s*([\d.]+)"
-        match = re.search(pattern, str(Center_p0_error))
-        if match:
-            Center_p0_errorval = float(match.group(1))
-        else:
-            Center_p0_errorval=np.nan
-
-
-
-        #Ne_center=Ne_center
-        #rough_peak_positions=Ne_center-2
-        if model_name == 'PseudoVoigtModel':
-            model1 = PseudoVoigtModel(prefix='p1_')#+ ConstantModel(prefix='c0')
-        if model_name=="VoigtModel":
-            model1 = VoigtModel(prefix='p1_')#+ ConstantModel(prefix='c0')
-            
-        if model_name=='SkewedVoigtModel':
-            model1=SkewedVoigtModel(prefix='p1_')
+        model1 = globals()[model_name](prefix='p1_')
             
         pars1 = model1.make_params()
         pars1['p1_'+ 'amplitude'].set(Amp_p0, min=min_off*Amp_p0, max=max_off*Amp_p0)
@@ -791,13 +972,7 @@ const_params=True, spec_res=0.4) :
 
 
         # Second wee peak
-        prefix='p2_'
-        if model_name == 'PseudoVoigtModel':
-            peak = PseudoVoigtModel(prefix='p2_')#+ ConstantModel(prefix='c0')
-        if model_name=="VoigtModel":
-            peak = VoigtModel(prefix='p2_')#+ ConstantModel(prefix='c0')
-        if model_name=='SkewedVoigtModel':
-            peak=SkewedVoigtModel(prefix='p2_')
+        peak = globals()[model_name](prefix='p2_')
 
 
         pars = peak.make_params()
@@ -847,28 +1022,13 @@ const_params=True, spec_res=0.4) :
 
 
     if peaks_pk1==1:
-
-        if model_name == 'PseudoVoigtModel':
-            model_combo = PseudoVoigtModel(prefix='p1_')#+ ConstantModel(prefix='c0')
-        if model_name=="VoigtModel":
-            model_combo= VoigtModel(prefix='p1_')#+ ConstantModel(prefix='c0')
-        if model_name=='SkewedVoigtModel':
-            model_combo=SkewedVoigtModel(prefix='p1_')
-
-
-
+        model_combo = globals()[model_name](prefix='p1_')
         # create parameters with initial values
         pars1 = model_combo.make_params()
-        pars1['p1_amplitude'].set(amplitude)
+        pars1['p1_amplitude'].set(amplitude,  min=amplitude*min_off, max=amplitude*max_off)
         pars1['p1_' + 'center'].set(Ne_center, min=Ne_center-2*spec_res,max=Ne_center+2*spec_res)
         pars1['p1_'+ 'sigma'].set(pk1_sigma, min=pk1_sigma*min_off, max=pk1_sigma*max_off)
 
-        
-
-
-
-
-
     
     result = model_combo.fit(ydat, pars1, x=xdat)
     
@@ -876,52 +1036,18 @@ const_params=True, spec_res=0.4) :
     # Need to check errors output
     Error_bars=result.errorbars
 
-
-
     # Get center value
     Center_p1=result.best_values.get('p1_center')
-    
-    
-    
     error_pk1 = result.params['p1_center'].stderr
-  
     
+    Center_pk2_error=result.params.get('p1_center')
 
+  
     # Get mix of lorenz
     Peak1_Prop_Lor=result.best_values.get('p1_fraction')
 
 
-   
-
-    if peaks_pk1>1:
-        Center_p2=result.best_values.get('p2_center')
-        Center_p2_error=result.params.get('p2_center')
-
-
 
-        # # Check if nonsense, e.g. if center 2 miles away, just use center 0
-        # if Center_p2 is not None:
-        #     if Center_p2>Center_p0 or Center_p2<1112:
-        #         Center_pk1=Center_p0
-        #         error_pk1=Center_p0_errorval
-        #         if block_print is False:
-        #             print('No  meaningful second peak found')
-        # 
-        #     elif Center_p1 is None and Center_p2 is None:
-        #         if block_print is False:
-        #             print('No peaks found')
-        #     elif Center_p1 is None and Center_p2>0:
-        #         Center_pk1=Center_p2
-        #         error_pk1=Center_p2_errorval
-        #     elif Center_p2 is None and Center_p1>0:
-        #         Center_pk1=Center_p1
-        #         error_pk1=Center_p1_errorval
-        #     elif Center_p1>Center_p2:
-        #         Center_pk1=Center_p1
-        #         
-        #     elif Center_p1<Center_p2:
-        #         Center_pk1=Center_p2
-                
 
     Area_pk1=result.best_values.get('p1_amplitude')
     sigma_pk1=result.best_values.get('p1_sigma')
@@ -943,115 +1069,7 @@ const_params=True, spec_res=0.4) :
     return Center_pk1, Area_pk1, sigma_pk1, gamma_pk1, Ne_pk1_reg_x_plot, Ne_pk1_reg_y_plot, Ne_pk1_reg_x, Ne_pk1_reg_y, xx_pk1, result_pk1, error_pk1, result_pk1_origx, comps, Peak1_Prop_Lor
 
 
-def fit_pk2(x, y_corr, x_span=[-5, 5], Ne_center=1447.5, amplitude=1000, pk2_sigma=0.4,
-model_name='PseudoVoigtModel', print_report=False, const_params=True, spec_res=0.4) :
-    """ This function fits the 1447 Ne line as a single Voigt
-
-    Parameters
-    -----------
-
-    x: np.array
-        x coordinate (wavenumber)
-
-    y: np.array
-        Background corrected intensiy
-
-    x_span: list length 2. Default [-5, 5]
-        Span either side of peak center used for fitting,
-        e.g. by default, fits to 5 wavenumbers below peak, 5 above.
-
-    Ne_center: float (default=1447.5)
-        Center position for Ne line being fitted
-
-    amplitude: integer (default = 1000)
-        peak amplitude
-
-    sigma: float (default =0.28)
-        sigma of the voigt peak
-
-
-    print_report: bool
-        if True, prints fit report.
-
-
-    """
-    if const_params is True:
-        min_off=0.8
-        max_off=1.2
-    if const_params is False:
-        min_off=0
-        max_off=100
-
-
-    # This defines the range you want to fit (e.g. how big the tails are)
-    lower_pk2=Ne_center+x_span[0]
-    upper_pk2=Ne_center+x_span[1]
-
-    # This segments into the x and y variable, and variables to plot, which are a bit bigger.
-    Ne_pk2_reg_x=x[(x>lower_pk2)&(x<upper_pk2)]
-    Ne_pk2_reg_y=y_corr[(x>lower_pk2)&(x<upper_pk2)]
-    Ne_pk2_reg_x_plot=x[(x>(lower_pk2-3))&(x<(upper_pk2+3))]
-    Ne_pk2_reg_y_plot=y_corr[(x>(lower_pk2-3))&(x<(upper_pk2+3))]
-
-    if model_name == 'PseudoVoigtModel':
-        model = PseudoVoigtModel()#+ ConstantModel(prefix='c0')
-    if model_name=="VoigtModel":
-        model = VoigtModel()#+ ConstantModel(prefix='c0')
-    if model_name=="SkewedVoigtModel":
-        model = SkewedVoigtModel()#+ ConstantModel(prefix='c0')
-
-
-
-    # create parameters with initial values
-    params = model.make_params()
-
-    params['center'].set(Ne_center, min=Ne_center+x_span[0], max=Ne_center+x_span[1])
-    params['amplitude'].set(amplitude, min=amplitude*min_off, max=amplitude*max_off)
-    params['sigma'].set(pk2_sigma, min=pk2_sigma*min_off, max=pk2_sigma*max_off)
-
-
-    result = model.fit(Ne_pk2_reg_y.flatten(), params, x=Ne_pk2_reg_x.flatten())
-
-    # Get center value
-    Center_pk2=result.best_values.get('center')
-    Center_pk2_error=result.params.get('center')
-
-    Peak2_Prop_Lor=result.best_values.get('fraction')
-    
-
-
-    #print(result.best_values)
-
-    Area_pk2=result.best_values.get('amplitude')
-    sigma_pk2=result.best_values.get('sigma')
-    gamma_pk2=result.best_values.get('gamma')
-    # Have to strip away the rest of the string, as center + error
-    # print('debug:')
-    # print(Center_pk2_error)
-    # Center_pk2_errorval=float(str(Center_pk2_error).split()[4].replace(",", ""))
-    # error_pk2=Center_pk2_errorval
-    
-    
-    error_pk2=np.nan
-    
-    try:
-        error_pk2_str = str(Center_pk2_error).split('+/-')[1].split(' bounds')[0].strip()
-        error_pk2 = float(error_pk2_str.replace(",", ""))
-    except IndexError:
-        pass
-    
-   
-
-    # Evaluate the peak at 100 values for pretty plotting
-    xx_pk2=np.linspace(lower_pk2, upper_pk2, 2000)
-
-    result_pk2=result.eval(x=xx_pk2)
-    result_pk2_origx=result.eval(x=Ne_pk2_reg_x)
-
-    if print_report is True:
-         print(result.fit_report(min_correl=0.5))
 
-    return Center_pk2,Area_pk2, sigma_pk2, gamma_pk2,  Ne_pk2_reg_x_plot, Ne_pk2_reg_y_plot, Ne_pk2_reg_x, Ne_pk2_reg_y, xx_pk2, result_pk2, error_pk2, result_pk2_origx, Peak2_Prop_Lor
 
 ## Setting default Ne fitting parameters
 @dataclass
@@ -1071,6 +1089,7 @@ class Ne_peak_config:
 
     # Whether you want a secondary peak
     peaks_1: float=2
+    peaks_2: float=1
 
     # SPlitting
     DeltaNe_ideal: float= 330.477634
@@ -1092,8 +1111,12 @@ class Ne_peak_config:
     # Things for plotting the residual
     x_range_residual: float=7 # Shows how many x units to left and right is shown on residual plot
 
-    # Things for fitting a secondary peak on 1117
+    # Things for fitting a secondary peak on pk1
     LH_offset_mini: Tuple[float, float] = (1.5, 3)
+    # Same for Pk2
+    LH_offset_mini2: Tuple[float, float] = None
+    
+    
 
     # Optional, by default, fits to the points inside the baseline. Can also specify as values to make a smaller peak fit.
     x_span_pk1: Optional [Tuple[float, float]] = None # Tuple[float, float] = (-10, 8)
@@ -1124,77 +1147,86 @@ plot_figure=True, loop=True,
 
     filename and path: str
         used to save filename in datatable, and to make a new folder.
+        
+    prefix: bool
+        Whether or not the filename has a prefix
+        
+    Ne_center_1, Ne_center_2 : float
+        Approximate peak position of the 1st and 2nd Ne line
 
-    filetype: str
-        choose from 'Witec_ASCII', 'headless_txt', 'headless_csv', 'head_csv', 'Witec_ASCII',
-        'HORIBA_txt', 'Renishaw_txt'
-
-    amplitude: int or float
-        first guess of peak amplitude
-
+    Ne_prom_1, Ne_prom_2 : float
+        Approximate prominance of the 1st and 2nd Ne line      
+        
     plot_figure: bool
-        if True, saves figure of fit in a new folder
-
-    Loop: bool
-        If True, only returns df.
-
-    x_range_baseline: flt, int
-        How much x range outside selected baseline the baseline selection plot shows.
-
-    y_range_baseline: flt, int
-        How much above the baseline position is shown on the y axis.
-
-    x_range_peak: flt, int, or None
-        How much to either side of the peak to show on the final peak fitting plot
-
-
-    DeltaNe_ideal: float
-        Theoretical distance between the two peaks you have selected. Default is 330.477634 for
-        the 1117 and 1447 Neon for the Cornell Raman. You can calculate this using the calculate_Ne_line_positions
-
-
-    Things for Neon 1 (~1117):
-
-        N_poly_pk1_baseline: int
-            Degree of polynomial used to fit the background
-
-        Ne_center_1: float
-            Center position for Ne line being fitted
-
-        lower_bck_1, upper_bck1, upper_bck1: 3 lists of length 2:
-            Positions used for background relative to peak.[-50, -20] takes a
-            background -50 and -20 from the peak center
-
-        x_span_pk1: list length 2. Default [-10, 8]
-            Span either side of peak center used for fitting,
-            e.g. by default, fits to 10 wavenumbers below peak, 8 above.
-
-
-        peaks_1: int
-            How many peaks to fit to the 1117 Neon, if 2, tries to put a shoulder peak
-
-        LH_offset_mini: list
-            If peaks>1, puts second peak within this range left of the main peak
-
-
-
-
-    Things for Neon 2 (~1447):
-        N_poly_pk2_baseline: int
-            Degree of polynomial used to fit the background
-
-        Ne_center_2: float
-            Center position for Ne line being fitted
-
-        lower_bck_2, upper_bck2, upper_bck2: 3 lists of length 2:
-            Positions used for background relative to peak.[-50, -20] takes a
-            background -50 and -20 from the peak center
+        Plots a figure, nice to inspect fits, makes it slower
+        
+    loop: bool
+        
+    save_clipboard: bool
+        Saves results to clipboard if true
+    
+    close_figure: bool
+        Closes figure if True (useful in some editors)
+        
+    const_params: bool 
+        If true, means amplitude and peak sigma have to be closer to the guessed parameters (e.g. used after initial fit).  
+        E.g. forced within +-20% of estimated peak parameters if True, if false, +-100%.    
+        
 
-        x_span_pk2: list length 2. Default [-10, 8]
-            Span either side of peak center used for fitting,
-            e.g. by default, fits to 10 wavenumbers below peak, 8 above.
+    config parameters from Ne_peak_config():
+    
+        model_name: str
+            allowed_models = "VoigtModel", "PseudoVoigtModel", "Pearson4Model", "SkewedVoigtModel"
+            
+        N_poly_pk1_baseline, N_poly_pk1_baseline: int (default 1)
+            Degree of polynomial to fit to baseline around pk 
             
+        lower_bck_pk1, upper_bck1_pk1, upper_bck2_pk1: tuple
+        lower_bck_pk2, upper_bck1_pk2, upper_bck2_pk2: tuple
+            Background positions relative to estimated peak center. 
+            
+        peaks_1, peaks_2: int
+            Number of peaks to fit to peak 1. If you need 2 overlapping peaks, put this Ne line as pk1
+            if not 1, you also need LH_offset_mini=(1.5, 3). Means second peak put between 1.5 and 3 units left of the 1st peak.
+            
+        DeltaNe_ideal: float
+            Ideal distance between two lines calculated for your laser wavelength. 
+            
+        x_range_baseline_pk1, x_range_baseline_pk2: int, float
+            test
+            
+        y_range_baseline_pk1, y_range_baseline_pk2: int, float
+            test
+        
+        pk1_sigma, pk2_sigma: float (Default 0.4)
+            Estimated sigma of each peak
+        
+        x_range_peak:  flt, int, or None
+            How much to either side of the peak to show on the final peak fitting plot
+        
+        x_range_residual: flt
+            How much either side of the peak is used for calculating residual
+        
+        x_span_pk1,  x_span_pk2: float, default None
+            By default, function fits up to background, but can shrink that range here. 
+            
+    Returns
+    ------------
+    if loop is False:
+        return df, Ne_pk1_reg_x_plot, Ne_pk1_reg_y_plot
+    if loop is True:
+        return df
+        
+    Also returns figure. 
+    
     """
+    # Check model is supported
+    if config.model_name not in allowed_models:
+        raise ValueError(f"Unsupported model: {config.model_name}. Supported models are: {', '.join(allowed_models)}")
+
+
+    
+    
 
     # check they havent messed up background
     if config.lower_bck_pk1[0]>config.lower_bck_pk1[1]:
@@ -1217,6 +1249,7 @@ plot_figure=True, loop=True,
     spec_res=np.abs(x[1]-x[0])
     # Getting things from config file
     peaks_1=config.peaks_1
+    peaks_2=config.peaks_2
     DeltaNe_ideal=config.DeltaNe_ideal
 
     # Estimate amplitude from prominence and sigma you entered
@@ -1225,11 +1258,11 @@ plot_figure=True, loop=True,
 
 
     #Remove the baselines
-    y_corr_pk1, Py_base_pk1, x_pk1, Ne_short_pk1, Py_base_pk1, Baseline_ysub_pk1, Baseline_x_pk1=remove_Ne_baseline_pk1(Ne,
+    y_corr_pk1, Py_base_pk1, x_pk1, Ne_short_pk1, Py_base_pk1, Baseline_ysub_pk1, Baseline_x_pk1=remove_Ne_baseline_pk(Ne,
     N_poly_pk1_baseline=config.N_poly_pk1_baseline, Ne_center_1=Ne_center_1, sigma_baseline=config.sigma_baseline,
     lower_bck=config.lower_bck_pk1, upper_bck1=config.upper_bck1_pk1, upper_bck2=config.upper_bck2_pk1)
 
-    y_corr_pk2, Py_base_pk2, x_pk2, Ne_short_pk2, Py_base_pk2, Baseline_ysub_pk2, Baseline_x_pk2=remove_Ne_baseline_pk2(Ne, Ne_center_2=Ne_center_2, N_poly_pk2_baseline=config.N_poly_pk2_baseline, sigma_baseline=config.sigma_baseline,
+    y_corr_pk2, Py_base_pk2, x_pk2, Ne_short_pk2, Py_base_pk2, Baseline_ysub_pk2, Baseline_x_pk2=remove_Ne_baseline_pk(Ne, Ne_center_1=Ne_center_2, N_poly_pk1_baseline=config.N_poly_pk2_baseline, sigma_baseline=config.sigma_baseline,
     lower_bck=config.lower_bck_pk2, upper_bck1=config.upper_bck1_pk2, upper_bck2=config.upper_bck2_pk2)
 
 
@@ -1249,14 +1282,12 @@ plot_figure=True, loop=True,
         x_span_pk2=config.x_span_pk2
         x_span_pk2_dist=abs(config.x_span_pk2[1]-config.x_span_pk2[0])
 
-    # Fit the 1117 peak
-    cent_pk1, Area_pk1, sigma_pk1, gamma_pk1, Ne_pk1_reg_x_plot, Ne_pk1_reg_y_plot, Ne_pk1_reg_x, Ne_pk1_reg_y, xx_pk1, result_pk1, error_pk1, result_pk1_origx, comps, Peak1_Prop_Lor = fit_pk1(x_pk1, y_corr_pk1, x_span=x_span_pk1, Ne_center=Ne_center_1,model_name=config.model_name,  LH_offset_mini=config.LH_offset_mini, peaks_pk1=peaks_1, amplitude=Pk1_Amp, pk1_sigma=config.pk1_sigma,
+    # Fit Pk1
+    cent_pk1, Area_pk1, sigma_pk1, gamma_pk1, Ne_pk1_reg_x_plot, Ne_pk1_reg_y_plot, Ne_pk1_reg_x, Ne_pk1_reg_y, xx_pk1, result_pk1, error_pk1, result_pk1_origx, comps, Peak1_Prop_Lor = fit_Ne_pk(x_pk1, y_corr_pk1, x_span=x_span_pk1, Ne_center=Ne_center_1, model_name=config.model_name,  LH_offset_mini=config.LH_offset_mini, peaks_pk1=peaks_1, amplitude=Pk1_Amp, pk1_sigma=config.pk1_sigma,
     const_params=const_params, spec_res=spec_res)
 
-
-
-    # Fit the 1447 peak
-    cent_pk2,Area_pk2, sigma_pk2, gamma_pk2, Ne_pk2_reg_x_plot, Ne_pk2_reg_y_plot, Ne_pk2_reg_x, Ne_pk2_reg_y, xx_pk2, result_pk2, error_pk2, result_pk2_origx, Peak2_Prop_Lor = fit_pk2( x_pk2, y_corr_pk2, x_span=x_span_pk2,  Ne_center=Ne_center_2, model_name=config.model_name, amplitude=Pk2_Amp, pk2_sigma=config.pk2_sigma, const_params=const_params,spec_res=spec_res)
+    # Fit pk2 
+    cent_pk2,Area_pk2, sigma_pk2, gamma_pk2, Ne_pk2_reg_x_plot, Ne_pk2_reg_y_plot, Ne_pk2_reg_x, Ne_pk2_reg_y, xx_pk2, result_pk2, error_pk2, result_pk2_origx, comps2, Peak2_Prop_Lor = fit_Ne_pk( x_pk2, y_corr_pk2, x_span=x_span_pk2,  Ne_center=Ne_center_2, model_name=config.model_name, LH_offset_mini=config.LH_offset_mini2, peaks_pk1=peaks_2, amplitude=Pk2_Amp, pk1_sigma=config.pk2_sigma, const_params=const_params,spec_res=spec_res)
 
 
     # Calculate difference between peak centers, and Delta Ne